ParticleBlock.hpp

/*
 * ------------------------------------------------------------------------------------------------------------
 * 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_PARTICLEBLOCK_HPP_
#define GEOSX_MESH_PARTICLEBLOCK_HPP_
 
#include "mesh/generators/ParticleBlockABC.hpp"
#include "mesh/ParticleType.hpp"
 
#include "dataRepository/Group.hpp"
 
namespace geos
{
 
class ParticleBlock : public ParticleBlockABC
{
public:
 
 
  ParticleBlock() = delete;
 
  ParticleBlock( string const & name, Group * const parent );
 
  ParticleBlock( const ParticleBlock & init ) = delete;
 
  ~ParticleBlock();
 
 
 
 
 
  void setParticleType( ParticleType particleType );
 
  ParticleType getParticleType() const override
  { return m_particleType; }
 
  array1d< globalIndex > getParticleID() const override
  { return m_particleID; }
 
  void setParticleID( array1d< globalIndex > const particleID )
  { m_particleID = particleID; }
 
  array2d< real64 > getParticleCenter() const override
  { return m_particleCenter; }
 
  void setParticleCenter( array2d< real64 > const particleCenter )
  { m_particleCenter = particleCenter; }
 
  array2d< real64 > getParticleVelocity() const override
  { return m_particleVelocity; }
 
  void setParticleVelocity( array2d< real64 > const particleVelocity )
  { m_particleVelocity = particleVelocity; }
 
  array2d< real64 > getParticleMaterialDirection() const override
  { return m_particleMaterialDirection; }
 
  void setParticleMaterialDirection( array2d< real64 > const particleMaterialDirection )
  { m_particleMaterialDirection = particleMaterialDirection; }
 
  array1d< int > getParticleGroup() const override
  { return m_particleGroup; }
 
  void setParticleGroup( array1d< int > const particleGroup )
  { m_particleGroup = particleGroup; } // TODO: Rename to particleContactGroup
 
  array1d< int > getParticleSurfaceFlag() const override
  { return m_particleSurfaceFlag; }
 
  void setParticleSurfaceFlag( array1d< int > const particleSurfaceFlag )
  { m_particleSurfaceFlag = particleSurfaceFlag; }
 
  array1d< real64 > getParticleDamage() const override
  { return m_particleDamage; }
 
  void setParticleDamage( array1d< real64 > const particleDamage )
  { m_particleDamage = particleDamage; }
 
  array1d< real64 > getParticleStrengthScale() const override
  { return m_particleStrengthScale; }
 
  void setParticleStrengthScale( array1d< real64 > const particleStrengthScale )
  { m_particleStrengthScale = particleStrengthScale; }
 
  array1d< real64 > getParticleVolume() const override
  { return m_particleVolume; }
 
  void setParticleVolume( array1d< real64 > const particleVolume )
  { m_particleVolume = particleVolume; }
 
  array3d< real64 > getParticleRVectors() const override
  { return m_particleRVectors; }
 
  void setParticleRVectors( array3d< real64 > const particleRVectors )
  { m_particleRVectors = particleRVectors; }
 
  bool hasRVectors() const override
  { return m_hasRVectors; }
 
  localIndex numParticles() const override
  { return size(); }
 
  arrayView1d< globalIndex > localToGlobalMap()
  { return m_localToGlobalMap; }
 
  array1d< globalIndex > localToGlobalMap() const override
  { return m_localToGlobalMap; }
 
  void resize( dataRepository::indexType const numParticles ) override final;
 
 
 
 
private:
 
  array1d< globalIndex > m_localToGlobalMap;
 
  string_array m_externalPropertyNames;
 
  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;
 
  bool m_hasRVectors;
 
  array3d< real64 > m_particleRVectors;
 
  std::list< dataRepository::WrapperBase * > getExternalProperties() override
  {
    std::list< dataRepository::WrapperBase * > result;
    for( string const & externalPropertyName : m_externalPropertyNames )
    {
      result.push_back( &this->getWrapperBase( externalPropertyName ) );
    }
    return result;
  }
};
 
}
 
#endif /* GEOSX_MESH_CELLBLOCK_HPP_ */