DofManager.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 Total, S.A
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */

#ifndef GEOSX_LINEARALGEBRA_DOFMANAGER_HPP_
#define GEOSX_LINEARALGEBRA_DOFMANAGER_HPP_

#include "LvArray/src/SparsityPattern.hpp"
#include "common/DataTypes.hpp"
#include "linearAlgebra/interfaces/InterfaceTypes.hpp"
#include "mesh/ElementRegionManager.hpp"
#include "mesh/NodeManager.hpp"

namespace geosx
{

class DomainPartition;
class MeshLevel;
class ObjectManagerBase;
class FluxApproximationBase;

class DofManager
{
public:

  enum class Location
  {
    Elem, 
    Face, 
    Edge, 
    Node  
  };

  enum class Connector
  {
    Elem, 
    Face, 
    Edge, 
    Node, 
    None,  
    Stencil 
  };

  static localIndex constexpr MAX_FIELDS = 10;

  struct FieldDescription
  {
    string name; 
    Location location; 
    std::vector< string > regions; 
    localIndex numComponents; 
    string key; 
    string docstring; 
    localIndex numLocalDof; 
    globalIndex numGlobalDof; 
    globalIndex blockOffset;  
    globalIndex rankOffset; 
    globalIndex globalOffset; 
  };

  struct CouplingDescription
  {
    Connector connector = Connector::None;  
    std::vector< std::string > regions; 
    FluxApproximationBase const * stencils = nullptr; 
  };

  explicit DofManager( string name );

  DofManager( DofManager const & ) = delete;

  DofManager( DofManager && ) = default;

  DofManager & operator=( DofManager const & ) = delete;

  DofManager & operator=( DofManager && ) = delete;

  ~DofManager() = default;

  void clear();

  void setMesh( DomainPartition & domain,
                localIndex const meshLevelIndex = 0,
                localIndex const meshBodyIndex = 0 );

  void addField( string const & fieldName,
                 Location const location );

  void addField( string const & fieldName,
                 Location const location,
                 localIndex const components );

  void addField( string const & fieldName,
                 Location const location,
                 arrayView1d< string const > const & regions );

  void addField( string const & fieldName,
                 Location const location,
                 localIndex const components,
                 arrayView1d< string const > const & regions );

  void addCoupling( string const & rowFieldName,
                    string const & colFieldName,
                    Connector const connectivity );

  void addCoupling( string const & rowFieldName,
                    string const & colFieldName,
                    Connector const connectivity,
                    arrayView1d< string const > const & regions );

  void addCoupling( string const & rowFieldName,
                    string const & colFieldName,
                    Connector const connectivity,
                    bool const symmetric );

  void addCoupling( string const & rowFieldName,
                    string const & colFieldName,
                    Connector const connectivity,
                    arrayView1d< string const > const & regions,
                    bool const symmetric );

  void addCoupling( string const & fieldName,
                    FluxApproximationBase const & stencils );

  void reorderByRank();

  bool fieldExists( string const & name ) const;

  string const & getKey( string const & fieldName ) const;

  globalIndex numGlobalDofs( string const & fieldName = "" ) const;

  localIndex numLocalDofs( string const & fieldName = "" ) const;

  array1d< localIndex > numLocalDofsPerField() const;


  array1d< localIndex > getLocalDofComponentLabels() const;

  globalIndex rankOffset( string const & fieldName = "" ) const;

  localIndex numComponents( string const & fieldName = "" ) const;

  array1d< localIndex > numComponentsPerField() const;

  localIndex numLocalSupport( string const & fieldName ) const;

  globalIndex numGlobalSupport( string const & fieldName ) const;

  Location getLocation( string const & fieldName ) const;

  globalIndex globalOffset( string const & fieldName ) const;

  template< typename MATRIX >
  void setSparsityPattern( MATRIX & matrix,
                           bool closePattern = true ) const;

  template< typename MATRIX >
  void setSparsityPattern( MATRIX & matrix,
                           string const & rowFieldName,
                           string const & colFieldName,
                           bool closePattern = true ) const;

  void setSparsityPattern( SparsityPattern< globalIndex > & pattern ) const;

  void setSparsityPattern( SparsityPattern< globalIndex > & pattern,
                           string const & rowFieldName,
                           string const & colFieldName ) const;

  template< typename VECTOR >
  void copyVectorToField( VECTOR const & vector,
                          string const & srcFieldName,
                          string const & dstFieldName,
                          real64 const scalingFactor,
                          localIndex const loCompIndex = 0,
                          localIndex const hiCompIndex = -1 ) const;

  void copyVectorToField( arrayView1d< real64 const > const & localVector,
                          string const & srcFieldName,
                          string const & dstFieldName,
                          real64 const scalingFactor,
                          localIndex const loCompIndex = 0,
                          localIndex const hiCompIndex = -1 ) const;

  template< typename VECTOR >
  void addVectorToField( VECTOR const & vector,
                         string const & srcFieldName,
                         string const & dstFieldName,
                         real64 const scalingFactor,
                         localIndex const loCompIndex = 0,
                         localIndex const hiCompIndex = -1 ) const;

  void addVectorToField( arrayView1d< real64 const > const & localVector,
                         string const & srcFieldName,
                         string const & dstFieldName,
                         real64 const scalingFactor,
                         localIndex const loCompIndex = 0,
                         localIndex const hiCompIndex = -1 ) const;

  template< typename VECTOR >
  void copyFieldToVector( VECTOR & vector,
                          string const & srcFieldName,
                          string const & dstFieldName,
                          real64 const scalingFactor,
                          localIndex const loCompIndex = 0,
                          localIndex const hiCompIndex = -1 ) const;

  void copyFieldToVector( arrayView1d< real64 > const & localVector,
                          string const & srcFieldName,
                          string const & dstFieldName,
                          real64 const scalingFactor,
                          localIndex const loCompIndex = 0,
                          localIndex const hiCompIndex = -1 ) const;

  template< typename VECTOR >
  void addFieldToVector( VECTOR & vector,
                         string const & srcFieldName,
                         string const & dstFieldName,
                         real64 const scalingFactor,
                         localIndex const loCompIndex = 0,
                         localIndex const hiCompIndex = -1 ) const;

  void addFieldToVector( arrayView1d< real64 > const & localVector,
                         string const & srcFieldName,
                         string const & dstFieldName,
                         real64 const scalingFactor,
                         localIndex const loCompIndex = 0,
                         localIndex const hiCompIndex = -1 ) const;

  struct SubComponent
  {
    string fieldName;  
    localIndex loComp; 
    localIndex hiComp; 
  };

  std::vector< SubComponent >
  filterDofs( std::vector< SubComponent > const & excluded ) const;

  template< typename MATRIX >
  void makeRestrictor( std::vector< SubComponent > const & selection,
                       MPI_Comm const & comm,
                       bool transpose,
                       MATRIX & restrictor ) const;

  void printFieldInfo( std::ostream & os = std::cout ) const;

private:

  void initializeDataStructure();

  localIndex getFieldIndex( string const & name ) const;

  void createIndexArray( FieldDescription & field );

  void removeIndexArray( FieldDescription const & field );

  template< typename MATRIX >
  void setSparsityPatternOneBlock( MATRIX & pattern,
                                   localIndex const rowFieldIndex,
                                   localIndex const colFieldIndex ) const;

  template< typename MATRIX >
  void setSparsityPatternFromStencil( MATRIX & pattern,
                                      localIndex const fieldIndex ) const;

  void countRowLengthsOneBlock( arrayView1d< localIndex > const & rowLengths,
                                localIndex const rowFieldIndex,
                                localIndex const colFieldIndex ) const;

  void countRowLengthsFromStencil( arrayView1d< localIndex > const & rowLengths,
                                   localIndex const fieldIndex ) const;

  void setSparsityPatternOneBlock( SparsityPattern< globalIndex > & pattern,
                                   localIndex const rowFieldIndex,
                                   localIndex const colFieldIndex ) const;

  void setSparsityPatternFromStencil( SparsityPattern< globalIndex > & pattern,
                                      localIndex const fieldIndex ) const;

  template< int DIMS_PER_DOF >
  void setFiniteElementSparsityPattern( SparsityPattern< globalIndex > & pattern,
                                        localIndex const fieldIndex ) const;

  template< typename FIELD_OP, typename POLICY, typename LOCAL_VECTOR >
  void vectorToField( LOCAL_VECTOR const localVector,
                      string const & srcFieldName,
                      string const & dstFieldName,
                      real64 const scalingFactor,
                      localIndex const loCompIndex,
                      localIndex const hiCompIndex ) const;

  template< typename FIELD_OP, typename POLICY, typename LOCAL_VECTOR >
  void fieldToVector( LOCAL_VECTOR localVector,
                      string const & srcFieldName,
                      string const & dstFieldName,
                      real64 const scalingFactor,
                      localIndex const loCompIndex,
                      localIndex const hiCompIndex ) const;

  string m_name;

  DomainPartition * m_domain = nullptr;

  MeshLevel * m_mesh = nullptr;

  std::vector< FieldDescription > m_fields;

  std::vector< std::vector< CouplingDescription > > m_coupling;

  bool m_reordered;
};

} /* namespace geosx */

#endif /*GEOSX_LINEARALGEBRA_DOFMANAGER_HPP_*/