WellControls.hpp

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 TotalEnergies
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
/*
 * @file WellControls.hpp
 */
 
 
#ifndef GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLCONTROLS_HPP
#define GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLCONTROLS_HPP
 
#include "common/format/EnumStrings.hpp"
#include "dataRepository/Group.hpp"
#include "functions/TableFunction.hpp"
 
namespace geos
{
namespace dataRepository
{
namespace keys
{
static constexpr auto wellControls = "WellControls";
}
}
 
 
class WellControls : public dataRepository::Group
{
public:
 
  enum class Type : integer
  {
    PRODUCER,  
    INJECTOR   
  };
 
 
  enum class Control : integer
  {
    BHP,  
    PHASEVOLRATE, 
    TOTALVOLRATE, 
    MASSRATE, 
    UNINITIALIZED, 
  };
 
 
 
  explicit WellControls( string const & name, dataRepository::Group * const parent );
 
 
  ~WellControls() override;
 
  WellControls() = delete;
 
  WellControls( WellControls const & ) = delete;
 
  WellControls( WellControls && ) = delete;
 
  WellControls & operator=( WellControls const & ) = delete;
 
  WellControls & operator=( WellControls && ) = delete;
 
 
 
  void switchToBHPControl( real64 const & val );
 
  void switchToTotalRateControl( real64 const & val );
 
  void switchToMassRateControl( real64 const & val );
 
  void switchToPhaseRateControl( real64 const & val );
 
  Control getControl() const { return m_currentControl; }
 
  void setControl( Control const & newControl )  {  m_currentControl = newControl; }
 
  Control getInputControl() const { return m_inputControl; }
 
  real64 getReferenceElevation() const { return m_refElevation; }
 
  real64 getReferenceGravityCoef() const { return m_refGravCoef; }
 
  void setReferenceGravityCoef( real64 const & refGravCoef ) { m_refGravCoef = refGravCoef; }
 
 
  real64 getTargetBHP( real64 const & currentTime ) const
  {
    return m_targetBHPTable->evaluate( &currentTime );
  }
 
  real64 getTargetTotalRate( real64 const & currentTime ) const
  {
    return m_rateSign * m_targetTotalRateTable->evaluate( &currentTime );
  }
 
  real64 getTargetPhaseRate( real64 const & currentTime ) const
  {
    return m_rateSign * m_targetPhaseRateTable->evaluate( &currentTime );
  }
 
  real64 getTargetMassRate( real64 const & currentTime ) const
  {
    return m_rateSign * m_targetMassRateTable->evaluate( &currentTime );
  }
 
  const string & getTargetPhaseName() const { return m_targetPhaseName; }
 
  arrayView1d< real64 const > getInjectionStream() const { return m_injectionStream; }
 
  real64 getInjectionTemperature() const { return m_injectionTemperature; }
 
  integer useSurfaceConditions() const { return m_useSurfaceConditions; }
 
  const real64 & getSurfacePressure() const { return m_surfacePres; }
 
  const real64 & getSurfaceTemperature() const { return m_surfaceTemp; }
 
  bool isInjector() const { return ( m_type == Type::INJECTOR ); }
 
  bool isProducer() const { return ( m_type == Type::PRODUCER ); }
 
  bool isWellOpen( real64 const & currentTime ) const;
 
  bool isCrossflowEnabled() const { return m_isCrossflowEnabled; }
 
  real64 getInitialPressureCoefficient() const { return m_initialPressureCoefficient; }
 
  void setNextDtFromTables( real64 const currentTime, real64 & nextDt );
 
 
  struct viewKeyStruct
  {
    static constexpr char const * refElevString() { return "referenceElevation"; }
    static constexpr char const * typeString() { return "type"; }
    static constexpr char const * inputControlString() { return "control"; }
    static constexpr char const * currentControlString() { return "currentControl"; }
    static constexpr char const * targetBHPString() { return "targetBHP"; }
    static constexpr char const * targetTotalRateString() { return "targetTotalRate"; }
    static constexpr char const * targetPhaseRateString() { return "targetPhaseRate"; }
    static constexpr char const * targetPhaseNameString() { return "targetPhaseName"; }
    static constexpr char const * targetMassRateString() { return "targetMassRate"; }
    static constexpr char const * injectionStreamString() { return "injectionStream"; }
    static constexpr char const * injectionTemperatureString() { return "injectionTemperature"; }
    static constexpr char const * useSurfaceConditionsString() { return "useSurfaceConditions"; }
    static constexpr char const * surfacePressureString() { return "surfacePressure"; }
    static constexpr char const * surfaceTemperatureString() { return "surfaceTemperature"; }
    static constexpr char const * targetTotalRateTableNameString() { return "targetTotalRateTableName"; }
    static constexpr char const * targetPhaseRateTableNameString() { return "targetPhaseRateTableName"; }
    static constexpr char const * targetMassRateTableNameString() { return "targetMassRateTableName"; }
    static constexpr char const * targetBHPTableNameString() { return "targetBHPTableName"; }
    static constexpr char const * statusTableNameString() { return "statusTableName"; }
    static constexpr char const * enableCrossflowString() { return "enableCrossflow"; }
    static constexpr char const * initialPressureCoefficientString() { return "initialPressureCoefficient"; }
 
  }
  viewKeysWellControls;
 
protected:
 
  virtual void postInputInitialization() override;
 
  void setNextDtFromTable( TableFunction const * table, real64 const currentTime, real64 & nextDt );
 
private:
 
  Type m_type;
 
  real64 m_refElevation;
 
  real64 m_refGravCoef;
 
  Control m_inputControl;
 
  Control m_currentControl;
 
  real64 m_targetBHP;
 
  real64 m_targetTotalRate;
 
  real64 m_targetPhaseRate;
 
  string m_targetPhaseName;
 
  real64 m_targetMassRate;
 
  array1d< real64 > m_injectionStream;
 
  real64 m_injectionTemperature;
 
  integer m_useSurfaceConditions;
 
  real64 m_surfacePres;
 
  real64 m_surfaceTemp;
 
  string m_targetTotalRateTableName;
 
  string m_targetPhaseRateTableName;
 
  string m_targetMassRateTableName;
 
  string m_targetBHPTableName;
 
  string m_statusTableName;
 
  integer m_isCrossflowEnabled;
 
  real64 m_initialPressureCoefficient;
 
  real64 m_rateSign;
 
  TableFunction const * m_targetTotalRateTable;
 
  TableFunction const * m_targetPhaseRateTable;
 
  TableFunction const * m_targetMassRateTable;
 
  TableFunction const * m_targetBHPTable;
 
  TableFunction const * m_statusTable;
};
 
ENUM_STRINGS( WellControls::Type,
              "producer",
              "injector" );
 
ENUM_STRINGS( WellControls::Control,
              "BHP",
              "phaseVolRate",
              "totalVolRate",
              "massRate",
              "uninitialized" );
 
 
} //namespace geos
 
#endif //GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLCONTROLS_HPP