Space.h

Go to the documentation of this file.

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material unless having a written signed agreement with Algoryx Simulation AB, or having been
advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
valid commercial license from Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
 
#pragma once
 
#include <agxCollide/agxCollide.h>
#include <agx/HashVector.h>
 
#include <agx/SetVector.h>
#include <agx/Vector.h>
#include <agx/HashSet.h>
#include <string>
 
#include <agxCollide/Geometry.h>
#include <agxCollide/HierarchicalGrid.h>
#include <agxCollide/Contacts.h>
#include <agxCollide/DisabledCollisionsState.h>
 
#include <agxCollide/SweepAndPrune.h>
#include <agxCollide/GeometryPair.h>
#include <agxCollide/CollisionGroupManager.h>
#include <agxCollide/Sphere.h>
#include <agx/Task.h>
#include <agx/Timer.h>
#include <agx/Component.h>
#include <agx/HashTableComponent.h>
 
#include <agx/Physics/GeometryContactEntity.h>
#include <agx/Physics/ContactPointEntity.h>
#include <agx/Physics/ParticleGeometryContactEntity.h>
#include <agx/Physics/ParticlePairContactEntity.h>
#include <agxCollide/SpaceListener.h>
 
 
namespace agxIO
{
  class SceneExporter;
}
 
namespace agx
{
  class ParticleSystem;
}
 
namespace agxSDK
{
  class Simulation;
}
 
namespace agxUtil {
  class ReconfigureRequest;
}
 
namespace agxCollide
{
  typedef agx::Vector<agx::Physics::BroadPhasePairPtr, agxData::BufferProxyAllocator> BroadPhasePairVector;
  typedef agx::Vector<agx::Physics::GeometryPairPtr, agxData::BufferProxyAllocator> SeparationPairVector;
  typedef agx::Vector<agx::Physics::GeometryPairPtr> LocalSeparationPairVector;
  typedef std::pair<agx::Physics::ParticlePtr, agx::Physics::GeometryPtr> ParticleGeometryPair;
  typedef agx::Vector<ParticleGeometryPair> ParticleGeometryPairVector;
 
  typedef agx::Vector<agx::Physics::ParticleGeometryContactPtr> ParticleGeometryContactVector;
  typedef agx::Vector<agx::Physics::ParticlePairContactPtr>     ParticlePairContactVector;
 
  AGX_DECLARE_POINTER_TYPES(Space);
 
  class AGXPHYSICS_EXPORT Space : public agx::Component, public virtual agxStream::Serializable
  {
    public:
 
      enum BroadPhaseAlgorithm {
        INVALID_BROAD_PHASE_ALGORITHM = -1,
        SWEEP_AND_PRUNE, 
        HIERARCHICAL_GRID 
      };
 
      Space();
 
      Space(agx::Device* device);
 
      void cleanup();
 
      bool setBroadPhaseAlgorithm(BroadPhaseAlgorithm algorithm);
 
      BroadPhaseAlgorithm getBroadPhaseAlgorithm() const;
 
      bool add( Geometry* geometry );
 
      bool remove( Geometry* geometry );
 
      const Geometry* getGeometry( const agx::Name& name ) const;
 
      Geometry* getGeometry( const agx::Name& name );
 
      const Geometry* getGeometry( const agx::Uuid& uuid ) const;
 
      Geometry* getGeometry( const agx::Uuid& uuid );
 
      const Geometry* getGeometryWithEntityId(agx::Index id) const;
 
      Geometry* getGeometryWithEntityId(agx::Index id);
 
      const GeometryRefVector& getGeometries() const;
 
      void updateBroadPhase();
 
      void update();
 
      void updateNarrowPhase();
 
      const GeometryContactPtrVector& getGeometryContacts() const;
 
      size_t getGeometryContacts(GeometryContactPtrVector& matches, const agxCollide::Geometry *geometry1, const agxCollide::Geometry *geometry2 = nullptr) const;
 
      size_t getGeometryContacts(GeometryContactPtrVector& matches, const agx::RigidBody *body1, const agx::RigidBody *body2 = nullptr) const;
 
      GeometryContactPtrVector::const_iterator removeContact(GeometryContactPtrVector::const_iterator contact);
 
      void addGeometryContacts(const LocalGeometryContactVector& localContacts);
 
      void addListener(agxCollide::SpaceListener* listener);
 
      bool removeListener(agxCollide::SpaceListener* listener);
 
      bool testBoundingVolumeOverlap(
        GeometryPtrVector& testGeometries,
        GeometryPairVector& geometryPairs,
        ParticleGeometryPairVector& particleGeometryPairs,
        bool skip = true );
 
      bool testGeometryOverlap(
        GeometryPtrVector& testGeometries,
        LocalGeometryContactVector& geometryContacts,
        LocalParticleGeometryContactVector& particleGeometryContacts,
        bool skip = true
      );
 
      GeometryContact getContact(Geometry* g1, Geometry* g2) const;
 
      bool intersect(
        const agx::Vec3& point,
        const agx::Vec3& direction,
        LocalGeometryContactVector& geometryContacts,
        LocalParticleGeometryContactVector& particleGeometryContacts,
        const agx::Real length = FLT_MAX / 4
      );
 
      void setEnableContactReduction( bool flag );
 
      void setContactReductionBinResolution(agx::UInt binResolution);
 
      bool getEnableContactReduction() const;
 
      agx::UInt getContactReductionBinResolution() const;
 
      void setContactReductionThreshold(agx::UInt threshold);
 
      agx::UInt getContactReductionThreshold() const;
 
      agx::UInt32 getUniqueGroupID();
 
      void setEnablePair( agx::UInt32 group1, agx::UInt32 group2, bool flag );
      void setEnablePair( const agx::Name& group1, const agx::Name& group2, bool flag );
 
      bool getEnablePair( agx::UInt32 group1, agx::UInt32 group2 ) const;
 
      bool getEnablePair(const agx::Name& group1, const agx::Name& group2) const;
 
      template< typename F >
      void enableForContacts(F relevantCollision)
      {
        // For all COMBINATIONS of geometries, check if the collision is possibly relevant
        // and add them to broad phase if their bounding volumes are overlapping.
        for ( agx::UInt i = 0, numGeometries = m_geometries.size(); !m_geometries.empty() && i < numGeometries - 1; ++i ) {
          for ( agx::UInt j = i + 1; j < numGeometries; ++j ) {
            if ( i == j )
              continue;
 
            // Relevant collision:
            // Report overlap.
            if ( relevantCollision(m_geometries[ i ], m_geometries[ j ] ) &&
              m_sweepAndPrune && // Only need to report overlaps to SAP, the grid will find them by itself on its next search.
              canCollide( m_geometries[ i ], m_geometries[ j ] ) &&
              m_geometries[ i ]->getBoundingVolume()->hasOverlap( *m_geometries[ j ]->getBoundingVolume() ) ) {
                reportOverlap( m_geometries[ i ], m_geometries[ j ] );
            }
          }
        }
      }
 
      template< typename F >
      void disableForContacts(F relevantCollision)
      {
        // Among the current broad phase pairs, check if we have
        // a relevant match of geometries. If so, remove (will send
        // separation event if someone is listening to that).
        GeometryPairVector pairsToRemove;
        pairsToRemove.reserve( 16 );
 
        const BroadPhasePairVector& broadPhasePairs = getBroadPhasePairs();
        for ( agx::UInt i = 0, numBroadPhasePairs = broadPhasePairs.size(); i < numBroadPhasePairs; ++i ) {
          const BroadPhasePairVector::value_type& bpPair = broadPhasePairs[ i ];
          if ( bpPair.geometry1() && bpPair.geometry2() && relevantCollision(bpPair.geometry1().model(), bpPair.geometry2().model() ) )
            pairsToRemove.push_back( GeometryPair( bpPair.geometry1().model(), bpPair.geometry2().model() ) );
        }
 
        while ( !pairsToRemove.empty() ) {
          if (m_sweepAndPrune)
            m_sweepAndPrune->removePair( pairsToRemove.back().first, pairsToRemove.back().second );
          pairsToRemove.pop_back();
        }
      }
 
      void insertDisabledGroupPair( agx::UInt32 group1, agx::UInt32 group2 );
 
      void eraseDisabledGroupPair( agx::UInt32 group1, agx::UInt32 group2 );
 
      bool canCollide( const Geometry* g1, const Geometry* g2 ) const;
 
      void setEnableCollisions(const Geometry* g1, const Geometry* g2, bool flag);
 
      // To be called for geometries that are enabled/disabled
      void setEnableGeometry(Geometry* geometry, bool flag);
 
      agx::Real getOrientedBoundsThreshold() const;
 
      void setOrientedBoundsThreshold( agx::Real threshold );
 
      void removeContact(agx::Physics::GeometryContactPtr contact);
 
      void commitRemovedContacts();
 
      const BroadPhasePairVector& getBroadPhasePairs() const;
 
      const SeparationPairVector& getSeparationPairs() const;
 
 
      size_t getSeparationPairs(agx::Physics::GeometryPairPtrVector &matches, const agxCollide::Geometry *geometry1, const agxCollide::Geometry *geometry2=nullptr) const;
 
      size_t getSeparationPairs(agx::Physics::GeometryPairPtrVector& matches, const agx::RigidBody *body1, const agx::RigidBody *body2=nullptr) const;
 
 
      void reportOverlap( agxCollide::Geometry* geometry1, agxCollide::Geometry* geometry2 );
 
      void removeOverlap( agxCollide::Geometry* geometry1, agxCollide::Geometry* geometry2 );
 
      agxCollide::SweepAndPrune* getSweepAndPrune();
 
      typedef agx::SetVector<GeometryPair> GeometryPairHash;
 
      const GeometryPairHash& getDisabledPairs() const;
 
      void resetParticleCellAssignments();
      void resetGeometryCellAssignments(agxCollide::Geometry* geometry);
 
 
      HierarchicalGrid *getHierarchicalGrid();
 
      const ParticleGeometryContactVector& getParticleGeometryContacts();
 
      const ParticlePairContactVector& getParticleParticleContacts();
 
      size_t computeNumberOfEnabledContactPoints() const;
 
      agxCollide::DisabledCollisionsState findDisabledCollisionsState() const;
 
    public:
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
 
      
      void synchronizeTransforms();
 
      void synchronizeBounds();
      void printContacts(const agx::String& title);
 
      CollisionGroupManager* getCollisionGroupManager();
      const CollisionGroupManager* getCollisionGroupManager() const;
 
      agxData::EntityStorage* getShapeStorage(agxData::EntityModel* shapeModel);
 
      agxData::EntityStorage *getGeometryStorage();
 
      agxData::EntityStorage* getGeometryContactStorage();
      agxData::EntityStorage* getContactPointStorage();
      agxData::EntityStorage* getOrientedGeometryBoundStorage();
 
      void setEnableParticleGridTasks(bool flag);
      void optimizeGridCellFitting();
 
      agx::TaskGroup* getUpdateTask();
 
 
      SpaceListener::GeometryEvent addGeometryEvent;
      SpaceListener::GeometryEvent removeGeometryEvent;
 
      SpaceListener::ShapeEvent addShapeEvent;
      SpaceListener::ShapeEvent removeShapeEvent;
 
      static agx::Model* ClassModel();
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agxCollide::Space );
 
      typedef agx::SymmetricPair<unsigned> GeometryIDPair;
 
      class SpaceSerializer : public agxStream::Serializable
      {
        public:
          SpaceSerializer( const agxCollide::Space* space ) : m_space(space) {}
          AGXSTREAM_DECLARE_SERIALIZABLE(agxCollide::Space::SpaceSerializer);
 
          const agxCollide::Space* getSpace() const {
            return m_space;
          }
          void setSpace( agxCollide::Space* space ) {
            m_space = space;
          }
 
          typedef agx::Vector<GeometryIDPair> DisablePairVector;
          DisablePairVector m_disabledGeometryIDPairs;
          agx::UInt32 m_uniqueGroupID;
 
        protected:
          SpaceSerializer( ) : m_space(nullptr) {}
          const Space* m_space;
 
      };
 
      friend class SpaceSerializer;
      friend class agxSDK::Simulation;
 
      DOXYGEN_END_INTERNAL_BLOCK()
 
    protected:
 
      virtual ~Space();
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
      void clearContactData();
 
      void garbageCollect(bool clearGcList = true);
 
      void restore( const SpaceSerializer& ss );
 
      void commitNewOverlaps();
 
      friend class Geometry;
 
      void init();
 
 
      template <typename T1, typename T2>
      void calculateNarrowPhase(BroadPhasePair* pair, T1& contactContainer, T2& separationContainer);
 
      void createGeometryContacts();
      void startUpdateTimer(agx::Task* task);
      void stopUpdateTimerAndReport(agx::Task* task);
      void createShapeStorage(const agx::Path& entityPath);
      void updateContactState();
      void createMissingContactMaterials();
      void assignPerContactPointParameters();
      void updateSweepAndPrune();
 
      void loadTasks(BroadPhaseAlgorithm algorithm);
      agx::Task* createSynchronizeTransformsTask();
      agx::Task* createSynchronizeBoundsTask();
      agx::Task* createUpdateBroadPhaseTask(BroadPhaseAlgorithm algorithm);
      agx::Task* createUpdateNarrowPhaseTask( const agx::String& implementation = "");
      agx::Task* createUpdateContactStateTask();
 
      void createParticlePairContacts();
      void createParticleGeometryContacts();
 
 
      DOXYGEN_END_INTERNAL_BLOCK()
 
    private:
      void validate();
 
      bool removeSweepAndPrune();
      bool removeGrid();
 
      friend class agxSDK::SimulationFrameWriter;
      friend class agxUtil::ReconfigureRequest;
 
      void setCollisionGroupManager(CollisionGroupManager* m);
 
      BroadPhaseAlgorithm m_broadPhaseAlgorithm;
 
      HierarchicalGridRef m_grid;
      agxCollide::SweepAndPruneRef m_sweepAndPrune;
 
      agx::TaskGroupRef m_updateTask;
      agx::TaskRef m_synchronizeTransformsTask;
      agx::TaskRef m_synchronizeBoundsTask;
      agx::TaskRef m_updateBroadPhaseTask;
      agx::TaskRef m_updateNarrowPhaseTask;
      agx::TaskRef m_updateContactStateTask;
      agx::TaskRef m_createMissingMaterialsTask;
      agx::TaskRef m_assignPerPointParameters;
 
      agx::TaskRef m_synchronizeTransformsTask2;
      agx::TaskRef m_synchronizeBoundsTask2;
      agx::TaskRef m_updateBroadPhaseTask2;
      agx::TaskRef m_updateNarrowPhaseTask2;
      agx::TaskRef m_updateContactStateTask2;
      agx::TaskRef m_createMissingMaterialsTask2;
      agx::TaskRef m_assignPerPointParameters2;
 
      GeometryRefVector m_geometries;
      agx::Vector<GeometryObserver> m_potentialProblemGeometries;
 
      agxData::EntityStorageRef m_geometryStorage;
      agxData::EntityStorageRef m_geometryContactStorage;
      agxData::EntityStorageRef m_contactPointStorage;
      agxData::EntityStorageRef m_broadPhasePairStorage;
      agxData::EntityStorageRef m_geometryContactSeparations;
      agxData::EntityStorageRef m_orientedGeometryBoundStorage;
      agxData::BufferRef m_materialLessGeometryContacts;
      agxData::BufferRef m_sortedGeometryContacts;
      agxData::BufferRef m_sortedSeparationPairs;
      agxData::BufferRef m_filteredBroadPhasePairs;
 
      BroadPhasePairVector m_broadPhasePairVector;
      SeparationPairVector m_separationPairVector;
 
      GeometryPairHash m_disabledGeometryPairs;
 
      friend class agxIO::SceneExporter;
      friend class agxCollide::SweepAndPrune;
 
      agxCollide::SweepAndPrune::ExternallyReportedPairsContainer m_externallyReportedPairs;
 
      typedef agx::HashVector< agx::Physics::GeometryPtr, GeometryRef > GeometryRemoveTable;
      GeometryRemoveTable m_geometriesToRemove;
 
      agx::Timer m_updateTimer;
      agx::Task::ExecutionEvent::CallbackType m_startUpdateTimerCallback;
      agx::Task::ExecutionEvent::CallbackType m_stopUpdateTimerAndReportCallback;
 
      agxData::ValueRefT<agx::Bool> m_contactReductionEnable;
      agxData::ValueRefT<agx::UInt> m_contactReductionBinResolution;
      agxData::ValueRefT<agx::UInt> m_contactReductionThreshold;
      agxData::ValueRefT<agx::UInt> m_narrowPhaseMinJobSize;
 
      agxData::ValueRefT<agx::Real> m_orientedBoundsThreshold;
 
      GeometryRef m_ray;
      SphereRef m_proxyParticle;
 
      GeometryContactPtrVector m_geometryContacts;
      agxData::BufferRef m_geometryContactInstanceBuffer;
      agxData::BufferRef m_contactPointInstanceBuffer;
 
      ParticleGeometryContactVector m_particleGeometryContacts;
      ParticlePairContactVector     m_particlePairContacts;
 
      typedef agx::HashTable<agxData::EntityModel*, agxData::EntityStorage*> ShapeStorageTable;
      ShapeStorageTable m_shapeStorageTable;
 
      typedef agx::Vector< SpaceListenerRef > SpaceListenerRefVector;
      SpaceListenerRefVector m_listeners;
      agxData::Buffer::Event::CallbackType m_shapeTransformReallocationCallback;
 
 
      agxData::EntityStorageRef m_collisionObjectStorage;
      agxData::BufferRef m_collisionObjectBuffer_sourceIndex;
      agxData::BufferRef m_collisionObjectBuffer_subsystem;
      agxData::BufferRef m_collisionObjectBuffer_position;
      agxData::BufferRef m_collisionObjectBuffer_radius;
      agxData::BufferRef m_collisionObjectBuffer_obbIndex;
 
      agxData::BufferRef m_gridOvelapBuffer_collisionObject1;
      agxData::BufferRef m_gridOvelapBuffer_collisionObject2;
 
      agx::TaskRef m_overlapTestTask;
 
      agx::HashSet<Geometry*> m_skipTable;
 
      typedef agx::HashTableComponent<agxData::GeometryPair, agx::Physics::GeometryContactPtr> GridContactTableComponent;
      typedef agx::QuadraticProbingHashTable<agxData::GeometryPair, agx::Physics::GeometryContactPtr, agx::HashFn<agxData::GeometryPair>, agxData::BufferProxyAllocator> GridContactTable;
 
 
      CollisionGroupManagerRef m_collisionGroupManager;
 
      agxData::Value::Event::CallbackType m_gridCellSizeAlignmentCallback;
      void gridCellSizeAlignmentCallback(agxData::Value* sizeAlignment);
 
      GridContactTable* m_gridContactTable;
  };
 
  /* Implementation */
  AGX_FORCE_INLINE  bool Space::canCollide( const Geometry* g1, const Geometry* g2 ) const
  {
    if (!(g1 && g2) )
      return false;
 
    // We cannot collide with ourself. TODO Not necessarily true in general case, e.g., if a deformable is defined as one geometry
    if (g1 == g2)
      return false;
 
    // One of the geometries are disabled for collision
    if (!(g1->isEnabled() && g2->isEnabled()))
      return false;
 
    if (!(g1->getEnableCollisions() && g2->getEnableCollisions()))
      return false;
 
    const agx::RigidBody* rb1 = g1->getRigidBody();
    const agx::RigidBody* rb2 = g2->getRigidBody();
 
    // If one is disabled, ignore overlap.
    if ( (rb1 && !rb1->getEnable()) || (rb2 && !rb2->getEnable()) )
      return false;
 
    // not same (non-null) body
    if (rb1 && (rb1 == rb2))
      return false;
 
    // Is this geometry pair disabled?
    if (m_disabledGeometryPairs.contains( GeometryPair(const_cast<Geometry*>(g1), const_cast<Geometry*>(g2)) ))
      return false;
 
    // Can these two groups collide?
    const agx::Physics::CollisionGroupSetPtr& groupSet1 = g1->getGroupSet();
    const agx::Physics::CollisionGroupSetPtr& groupSet2 = g2->getGroupSet();
    if (groupSet1 && groupSet2 && g1->getSpace() == this && g2->getSpace() == this && !m_collisionGroupManager->canSetsCollide(groupSet1, groupSet2))
      return false;
 
    return true;
  }
 
  DOXYGEN_START_INTERNAL_BLOCK()
 
  AGX_FORCE_INLINE agxData::EntityStorage* Space::getOrientedGeometryBoundStorage()
  {
    return m_orientedGeometryBoundStorage;
  }
 
  AGX_FORCE_INLINE agxData::EntityStorage* Space::getGeometryContactStorage()
  {
    return m_geometryContactStorage;
  }
 
  AGX_FORCE_INLINE agxData::EntityStorage* Space::getContactPointStorage()
  {
    return m_contactPointStorage;
  }
 
 
  AGX_FORCE_INLINE CollisionGroupManager* Space::getCollisionGroupManager()
  {
    return m_collisionGroupManager;
  }
 
  AGX_FORCE_INLINE const CollisionGroupManager* Space::getCollisionGroupManager() const
  {
    return m_collisionGroupManager;
  }
 
  AGX_FORCE_INLINE agxData::EntityStorage *Space::getGeometryStorage() { return m_geometryStorage; }
 
  DOXYGEN_END_INTERNAL_BLOCK()
 
  AGX_FORCE_INLINE const GeometryRefVector& Space::getGeometries() const
  {
    return m_geometries;
  }
 
  AGX_FORCE_INLINE bool Space::getEnablePair( const agx::Name& group1, const agx::Name& group2 ) const
  {
    return this->getEnablePair(
      m_collisionGroupManager->getGroupId(group1),
      m_collisionGroupManager->getGroupId(group2));
  }
 
  AGX_FORCE_INLINE bool Space::getEnablePair( agx::UInt32 group1, agx::UInt32 group2 ) const
  {
    return m_collisionGroupManager->canGroupsCollide(group1, group2);
  }
 
  AGX_FORCE_INLINE const BroadPhasePairVector& Space::getBroadPhasePairs() const
  {
    m_broadPhasePairVector.allocator().update();
    return m_broadPhasePairVector;
  }
 
  AGX_FORCE_INLINE const SeparationPairVector& Space::getSeparationPairs() const
  {
    m_separationPairVector.allocator().update();
    return m_separationPairVector;
  }
 
  AGX_FORCE_INLINE void Space::removeContact(agx::Physics::GeometryContactPtr contact)
  {
    if (contact)
      contact.enabled() = false;
  }
 
  AGX_FORCE_INLINE void Space::reportOverlap( Geometry* geometry1, Geometry* geometry2 )
  {
    if ( geometry1 == 0L || geometry2 == 0L || !geometry1->isEnabled() || !geometry2->isEnabled() )
      return;
 
    m_externallyReportedPairs.insert( SweepAndPrune::SymmetricGeometryPtrPair( geometry1, geometry2 ), SweepAndPrune::SymmetricGeometryRefPair( geometry1, geometry2 ) );
  }
 
  AGX_FORCE_INLINE void Space::removeOverlap( Geometry* geometry1, Geometry* geometry2 )
  {
    if ( m_sweepAndPrune == 0L || geometry1 == 0L || geometry2 == 0L )
      return;
 
    auto it = m_externallyReportedPairs.find( SweepAndPrune::SymmetricGeometryPtrPair( geometry1, geometry2 ) );
    if ( it != m_externallyReportedPairs.end() )
      m_externallyReportedPairs.erase( it );
    else
      m_sweepAndPrune->removePair( geometry1, geometry2 );
  }
 
  AGX_FORCE_INLINE bool Space::getEnableContactReduction() const
  {
    return m_contactReductionEnable->get();
  }
 
  AGX_FORCE_INLINE agx::UInt Space::getContactReductionBinResolution() const
  {
    return m_contactReductionBinResolution->get();
  }
 
  AGX_FORCE_INLINE agx::Real Space::getOrientedBoundsThreshold() const
  {
    return m_orientedBoundsThreshold->get();
  }
 
  AGX_FORCE_INLINE HierarchicalGrid *Space::getHierarchicalGrid() { return m_grid; }
 
}