ParticleSubRegionBase.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2018-2020 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2020 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2018-2020 TotalEnergies
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOSX_MESH_PARTICLESUBREGIONBASE_HPP_
#define GEOSX_MESH_PARTICLESUBREGIONBASE_HPP_
 
#include "mesh/ParticleType.hpp"
#include "mesh/ObjectManagerBase.hpp"
#include "mesh/mpiCommunications/CommunicationTools.hpp"
#include "mesh/mpiCommunications/MPI_iCommData.hpp"
#include "constitutive/solid/SolidBase.hpp"
#include "ToParticleRelation.hpp"
 
namespace geos
{
 
class ParticleManager;
class MeshLevel;
 
namespace constitutive
{
class ConstitutiveBase;
}
 
class ParticleSubRegionBase : public ObjectManagerBase
{
public:
 
 
  ParticleSubRegionBase( string const & name, dataRepository::Group * const parent );
 
  ~ParticleSubRegionBase();
 
 
 
  bool hasRVectors() const
  { return m_hasRVectors; }
 
  void setHasRVectors( bool hasRVectors )
  { m_hasRVectors = hasRVectors; }
 
  arrayView1d< globalIndex const > getParticleID() const
  { return m_particleID; }
 
  arrayView1d< globalIndex > getParticleID()
  { return m_particleID; }
 
  arrayView1d< int const > getParticleGroup() const
  { return m_particleGroup; }
 
  arrayView1d< int > getParticleGroup()
  { return m_particleGroup; }
 
  arrayView1d< int const > getParticleSurfaceFlag() const
  { return m_particleSurfaceFlag; }
 
  arrayView1d< int > getParticleSurfaceFlag()
  { return m_particleSurfaceFlag; }
 
  arrayView1d< real64 const > getParticleDamage() const
  { return m_particleDamage; }
 
  arrayView1d< real64 > getParticleDamage()
  { return m_particleDamage; }
 
 
  arrayView1d< real64 const > getParticleStrengthScale() const
  { return m_particleStrengthScale; }
 
  arrayView1d< real64 > getParticleStrengthScale()
  { return m_particleStrengthScale; }
 
 
  arrayView1d< int const > getParticleRank() const
  { return m_particleRank; }
 
  arrayView1d< int > getParticleRank()
  { return m_particleRank; }
 
  arrayView2d< real64 const > getParticleCenter() const
  { return m_particleCenter; }
 
  arrayView2d< real64 > getParticleCenter()
  { return m_particleCenter; }
 
  void setParticleCenter( array2d< real64 > particleCenter )
  { m_particleCenter = particleCenter; }
 
  arrayView2d< real64 const > getParticleVelocity() const
  { return m_particleVelocity; }
 
  arrayView2d< real64 > getParticleVelocity()
  { return m_particleVelocity; }
 
  arrayView2d< real64 const > getParticleMaterialDirection() const
  { return m_particleMaterialDirection; }
 
  arrayView2d< real64 > getParticleMaterialDirection()
  { return m_particleMaterialDirection; }
 
  arrayView1d< real64 const > getParticleVolume() const
  { return m_particleVolume; }
 
  arrayView1d< real64 > getParticleVolume()
  { return m_particleVolume; }
 
  arrayView3d< real64 const > getParticleRVectors() const
  { return m_particleRVectors; }
 
  arrayView3d< real64 > getParticleRVectors()
  { return m_particleRVectors; }
 
  dataRepository::Group const & getConstitutiveModels() const
  { return m_constitutiveModels; }
 
  dataRepository::Group & getConstitutiveModels()
  { return m_constitutiveModels; }
 
  template< typename T = constitutive::ConstitutiveBase >
  T const & getConstitutiveModel( string const & name ) const
  { return m_constitutiveModels.getGroup< T >( name ); }
 
  template< typename T = constitutive::ConstitutiveBase >
  T & getConstitutiveModel( string const & name )
  { return m_constitutiveModels.getGroup< T >( name ); }
 
  ParticleType getParticleType() const
  { return m_particleType; }
 
  virtual void setParticleType( ParticleType const particleType )
  { m_particleType = particleType; }
 
  int numberOfVerticesPerParticle() const
  { return m_numVerticesPerParticle; }
 
  virtual void setNumberOfVerticesPerParticle( ParticleType const particleType )
  {
    switch( particleType )
    {
      case ParticleType::SinglePoint:
      {
        m_numVerticesPerParticle = 1;
        break;
      }
      case ParticleType::CPDI:
      {
        m_numVerticesPerParticle = 8;
        break;
      }
      default:
      {
        GEOS_ERROR( "Particle type \"" << m_particleType << "\" is not yet supported." );
        break;
      }
    }
  }
 
  OrderedVariableToManyParticleRelation const & neighborList() const
  { return m_neighborList; }
 
  OrderedVariableToManyParticleRelation & neighborList()
  { return m_neighborList; }
 
 
  struct viewKeyStruct : ObjectManagerBase::viewKeyStruct
  {
    static constexpr char const * particleIDString() { return "particleID"; }
 
    static constexpr char const * particleGroupString() { return "particleGroup"; }
 
    static constexpr char const * particleSurfaceFlagString() { return "particleSurfaceFlag"; }
 
    static constexpr char const * particleDamageString() { return "particleDamage"; }
 
    static constexpr char const * particleStrengthScaleString() { return "particleStrengthScale"; }
 
    static constexpr char const * particleRankString() { return "particleRank"; }
 
    static constexpr char const * particleCenterString() { return "particleCenter"; }
 
    static constexpr char const * particleVelocityString() { return "particleVelocity"; }
 
    static constexpr char const * particleMaterialDirectionString() { return "particleMaterialDirection"; }
 
    static constexpr char const * particleVolumeString() { return "particleVolume"; }
 
    static constexpr char const * particleRVectorsString() { return "particleRVectors"; }
  };
 
  struct groupKeyStruct : public ObjectManagerBase::groupKeyStruct
  {
    static constexpr auto constitutiveModelsString() { return "ConstitutiveModels"; }
  };
 
  unsigned int particlePack( buffer_type & buffer,
                             arrayView1d< localIndex > const & localIndices,
                             bool doPack ) const;
 
  void particleUnpack( buffer_type & buffer,
                       int const & startingIndex,
                       int const & numberOfIncomingParticles );
 
  void erase( std::set< localIndex > const & indicesToErase );
 
  void setActiveParticleIndices();
 
  SortedArrayView< localIndex const > const activeParticleIndices() const
  {
    return m_activeParticleIndices.toView();
  }
 
  void updateMaps();
 
private:
  dataRepository::Group m_constitutiveModels;
 
protected:
  bool m_hasRVectors;
 
  int m_numVerticesPerParticle;
 
  array1d< int > m_particleRank;
 
  array1d< globalIndex > m_particleID;
 
  array1d< int > m_particleGroup;
 
  array1d< int > m_particleSurfaceFlag;
 
  array1d< real64 > m_particleDamage;
 
  array1d< real64 > m_particleStrengthScale;
 
  array2d< real64 > m_particleCenter;
 
  array2d< real64 > m_particleVelocity;
 
  array2d< real64 > m_particleMaterialDirection;
 
  array1d< real64 > m_particleVolume;
 
  ParticleType m_particleType;
 
  array3d< real64 > m_particleRVectors;
 
  SortedArray< localIndex > m_activeParticleIndices;
 
  OrderedVariableToManyParticleRelation m_neighborList;
 
};
 
 
} /* namespace geos */
 
#endif /* GEOSX_MESH_PARTICLESUBREGIONBASE_HPP_ */