hypredrive.hpp

#ifndef GEOS_LINEARALGEBRA_INTERFACES_HYPRE_HYPREDRIVE_HPP_
#define GEOS_LINEARALGEBRA_INTERFACES_HYPRE_HYPREDRIVE_HPP_
 
#include "common/LinearSolverBase.hpp"
#include "linearAlgebra/interfaces/hypre/HypreInterface.hpp"
 
#include <HYPREDRV.h>
 
#include <memory>
#include <string>
 
namespace geos
{
 
class HypreSolver;
class HypredriveSolverTestPeer;
 
namespace hypre
{
 
namespace hypredrive
{
 
enum class InputSource
{
  authoritativeFile,
  generatedFallback
};
 
struct InputArgsParseTarget
{
  InputSource source = InputSource::generatedFallback;
  std::string argument;
};
 
bool shouldUse( LinearSolverParameters const & params );
 
bool buildInputArgsParseTarget( LinearSolverParameters const & params,
                                InputArgsParseTarget & target );
 
bool buildInputArgsParseTarget( LinearSolverParameters const & params,
                                stdVector< string > const & fieldNames,
                                arrayView1d< int const > const & numComponentsPerField,
                                InputArgsParseTarget & target );
 
std::string formatInputArgsParseTargetYaml( InputArgsParseTarget const & target );
 
bool wasInputArgsParseTargetLogged( InputArgsParseTarget const & target );
 
void markInputArgsParseTargetLogged( InputArgsParseTarget const & target );
 
void logInputArgsParseTarget( LinearSolverParameters const & params,
                              InputArgsParseTarget const & target );
 
void initializeRuntime();
 
void finalizeRuntime();
 
}
 
}
 
class HypredriveSolver final : public LinearSolverBase< HypreInterface >
{
public:
 
  using Base = LinearSolverBase< HypreInterface >;
 
  explicit HypredriveSolver( LinearSolverParameters parameters );
 
  ~HypredriveSolver() override;
 
  void setExecutionContext( LinearSolverExecutionContext const & context ) override;
 
  void setNearNullKernel( arrayView1d< HypreVector const > const & nearNullKernel ) override;
 
  void setup( HypreMatrix const & mat ) override;
 
  void apply( HypreVector const & src,
              HypreVector & dst ) const override;
 
  void solve( HypreVector const & rhs,
              HypreVector & sol ) const override;
 
  void clear() override;
 
private:
 
  bool configureHypredrive( HypreMatrix const & mat );
 
  void createHypredrive( HypreMatrix const & mat,
                         hypre::hypredrive::InputArgsParseTarget const & parseTarget,
                         std::string const & configurationSignature,
                         std::string const & structureSignature,
                         arrayView1d< int > const & pointMarkers );
 
  void refreshBoundObjects( HypreMatrix const & mat,
                            arrayView1d< int > const & pointMarkers );
 
  void setupLegacy( HypreMatrix const & mat );
 
  void applyHypredrive( HypreVector const & rhs,
                        HypreVector & sol ) const;
 
  void syncExecutionAnnotations();
 
  void closeExecutionAnnotations();
 
  void syncLegacyResult() const;
 
  void destroyHypredrive();
 
  void resetHypredriveState();
 
  using Base::m_params;
  using Base::m_result;
 
  friend class HypredriveSolverTestPeer;
 
  LinearSolverExecutionContext m_executionContext{};
  std::string m_configurationSignature;
  std::string m_structureSignature;
  std::string m_activeTimestepScope;
  std::string m_activeNewtonScope;
  bool m_hasExecutionContext = false;
  bool m_timestepScopeActive = false;
  bool m_newtonScopeActive = false;
  arrayView1d< HypreVector const > m_nearNullKernel;
  bool m_reportedGeneratedYamlFailure = false;
  size_t m_hypredriveGeneration = 0;
  HYPREDRV_t m_hypredrive{};
  bool m_linearSolverCreated = false;
  mutable HypreVector m_dummyRhs;
  mutable HypreVector m_dummySol;
  mutable HypreVector m_residual;
  std::unique_ptr< HypreSolver > m_legacySolver;
};
 
}
 
#endif