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"
#include "constitutive/fluid/multifluid/MultiFluidBase.hpp"
 
#include "physicsSolvers/fluidFlow/wells/WellInjectionConstraint.hpp"
#include "physicsSolvers/fluidFlow/wells/WellProductionConstraint.hpp"
#include "physicsSolvers/fluidFlow/wells/WellBHPConstraints.hpp"
#include "physicsSolvers/fluidFlow/wells/WellVolumeRateConstraint.hpp"
#include "physicsSolvers/fluidFlow/wells/WellPhaseVolumeRateConstraint.hpp"
#include "physicsSolvers/fluidFlow/wells/WellMassRateConstraint.hpp"
#include "physicsSolvers/fluidFlow/wells/WellLiquidRateConstraint.hpp"
#include "constitutive/fluid/multifluid/MultiFluidBase.hpp"
#include "constitutive/fluid/singlefluid/SingleFluidBase.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 Status : integer
  {
    OPEN,  
    CLOSED   
  };
 
  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;
 
 
  virtual Group * createChild( string const & childKey, string const & childName ) override;
 
  virtual void expandObjectCatalogs() override;
 
  template< typename T0, typename T1, typename ... CASTTYPES, typename CONTAINERTYPE, typename LAMBDA >
  static bool applyLambdaToContainer( CONTAINERTYPE container, LAMBDA && lambda )
  {
    using Pointee = std::remove_pointer_t< std::remove_reference_t< CONTAINERTYPE > >;
    using T = std::conditional_t< std::is_const< Pointee >::value, T0 const, T0 >;
    T * const castedContainer = dynamic_cast< T * >( container );
 
    if( castedContainer != nullptr )
    {
      lambda( *castedContainer );
      return true;
    }
 
    return applyLambdaToContainer< T1, CASTTYPES... >( container, std::forward< LAMBDA >( lambda ) );
  }
 
  // Base case: no more types to try
  template< typename CONTAINERTYPE, typename LAMBDA >
  static bool applyLambdaToContainer( CONTAINERTYPE /*container*/, LAMBDA && /*lambda*/ )
  {
    return false;
  }
 
  // Single-type overload: try only T0 and stop
  template< typename T0, typename CONTAINERTYPE, typename LAMBDA >
  static bool applyLambdaToContainer( CONTAINERTYPE container, LAMBDA && lambda )
  {
    using Pointee = std::remove_pointer_t< std::remove_reference_t< CONTAINERTYPE > >;
    using T = std::conditional_t< std::is_const< Pointee >::value, T0 const, T0 >;
    T * const castedContainer = dynamic_cast< T * >( container );
 
    if( castedContainer != nullptr )
    {
      lambda( *castedContainer );
      return true;
    }
 
    return false;
  }
 
 
  template< typename GROUPTYPE = Group, typename ... GROUPTYPES, typename LAMBDA >
  void forInjectionConstraints( LAMBDA && lambda ) const
  {
    for( auto const * constraintIter : m_injectionRateConstraintList )
    {
      applyLambdaToContainer< GROUPTYPE, GROUPTYPES... >( constraintIter, [&]( auto const & castedSubGroup )
      {
        lambda( castedSubGroup );
      } );
    }
  }
 
  // non-const overload
  template< typename GROUPTYPE = Group, typename ... GROUPTYPES, typename LAMBDA >
  void forInjectionConstraints( LAMBDA && lambda )
  {
    for( auto * constraintIter : m_injectionRateConstraintList )
    {
      applyLambdaToContainer< GROUPTYPE, GROUPTYPES... >( constraintIter, [&]( auto & castedSubGroup )
      {
        lambda( castedSubGroup );
      } );
    }
  }
  template< typename GROUPTYPE = Group, typename ... GROUPTYPES, typename LAMBDA >
  void forProductionConstraints( LAMBDA && lambda ) const
  {
    for( auto const * constraintIter : m_productionRateConstraintList )
    {
      applyLambdaToContainer< GROUPTYPE, GROUPTYPES... >( constraintIter, [&]( auto const & castedSubGroup )
      {
        lambda( castedSubGroup );
      } );
    }
  }
 
  // non-const overload
  template< typename GROUPTYPE = Group, typename ... GROUPTYPES, typename LAMBDA >
  void forProductionConstraints( LAMBDA && lambda )
  {
    for( auto * constraintIter : m_productionRateConstraintList )
    {
      applyLambdaToContainer< GROUPTYPE, GROUPTYPES... >( constraintIter, [&]( auto & castedSubGroup )
      {
        lambda( castedSubGroup );
      } );
    }
  }
 
 
  Control getControl() const { return m_currentControl; }
 
  void setControl( Control const & newControl )  {  m_currentControl = newControl; }
 
  integer estimateSolution() const { return m_estimateSolution; }
 
  real64 getReferenceGravityCoef() const { return m_refGravCoef; }
 
  void setReferenceGravityCoef( real64 const & refGravCoef ) { m_refGravCoef = refGravCoef; }
 
 
  real64 getTargetBHP( real64 const & targetTime ) const;
 
 
  real64 getInjectionTemperature() const;
 
  arrayView1d< real64 const > getInjectionStream() const;
 
 
  integer getConstraintPhaseIndex() const;
 
  real64 getReferenceElevation() const;
 
 
  integer useSurfaceConditions() const { return m_useSurfaceConditions; }
 
  string referenceReservoirRegion() const { return m_referenceReservoirRegion; }
 
  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() const;
 
  void setWellState( bool open );
  bool getWellState() const;
 
 
  void setConstraintSwitch( bool constraintSwitch );
  bool getConstraintSwitch() const;
 
  void setCurrentConstraint( WellConstraintBase * currentConstraint ) { m_currentConstraint = currentConstraint;}
  WellConstraintBase *  getCurrentConstraint() { return m_currentConstraint; }
  WellConstraintBase const *  getCurrentConstraint() const { return m_currentConstraint; }
 
 
  bool isCrossflowEnabled() const { return m_isCrossflowEnabled; }
 
  real64 getInitialPressureCoefficient() const { return m_initialPressureCoefficient; }
 
  void setNextDtFromTables( real64 const & currentTime, real64 & nextDt );
 
 
  void setFluidSeparator( std::unique_ptr< constitutive::ConstitutiveBase > fluidSeparatorPtr )  {  m_fluidSeparatorPtr = std::move( fluidSeparatorPtr );}
  constitutive::MultiFluidBase & getMultiFluidSeparator()  { return dynamicCast< constitutive::MultiFluidBase & >( *m_fluidSeparatorPtr ); }
 
  constitutive::SingleFluidBase & getSingleFluidSeparator()  { return dynamicCast< constitutive::SingleFluidBase & >( *m_fluidSeparatorPtr ); }
 
 
  real64 getRegionAveragePressure() const { return m_regionAveragePressure; }
 
  void setRegionAveragePressure( real64 regionAveragePressure ) { m_regionAveragePressure = regionAveragePressure; }
 
  real64 getRegionAverageTemperature() const { return m_regionAverageTemperature; }
 
  void setRegionAverageTemperature( real64 regionAverageTemperature ) { m_regionAverageTemperature = regionAverageTemperature; }
 
  void setWellStatus ( real64 const & currentTime, WellControls::Status status );
 
  WellControls::Status getWellStatus () const { return m_wellStatus; }
 
  struct viewKeyStruct
  {
    static constexpr char const * refElevString() { return "referenceElevation"; }
    static constexpr char const * typeString() { return "type"; }
 
    static constexpr char const * currentControlString() { return "currentControl"; }
 
    static constexpr char const * useSurfaceConditionsString() { return "useSurfaceConditions"; }
    static constexpr char const * referenceReservoirRegionString() { return "referenceReservoirRegion"; }
    static constexpr char const * surfacePressureString() { return "surfacePressure"; }
    static constexpr char const * surfaceTemperatureString() { return "surfaceTemperature"; }
 
    static constexpr char const * statusTableNameString() { return "statusTableName"; }
    static constexpr char const * perfStatusTableNameString() { return "perfStatusTableName"; }
    static constexpr char const * enableCrossflowString() { return "enableCrossflow"; }
    static constexpr char const * initialPressureCoefficientString() { return "initialPressureCoefficient"; }
    static constexpr char const * estimateWellSolutionString() { return "estimateWellSolution"; }
 
    static constexpr char const * minimumBHPConstraintString() { return "MinimumBHPConstraint"; }
    static constexpr char const * maximumBHPConstraintString() { return "MaximumBHPConstraint"; }
    static constexpr char const * phaseProductionConstraintString() { return "PhaseProductionConstraint"; }
    static constexpr char const * phaseInjectionConstraintString() { return "PhaseInjectionConstraint"; }
    static constexpr char const * totalVolProductionConstraintString() { return "TotalVolProductionConstraint"; }
    static constexpr char const * totalVolInjectionConstraintString() { return "TotalVolInjectionConstraint"; }
    static constexpr char const * massProductionConstraintString() { return "massProductionConstraint"; }
    static constexpr char const * massInjectionConstraintString() { return "massInjectionConstraint"; }
    static constexpr char const * liquidProductionConstraintString() { return "liquidProductionConstraint"; }
  }
  viewKeysWellControls;
 
  static void setNextDtFromTable( TableFunction const * table, real64 const currentTime, real64 & nextDt );
 
  template< typename ConstraintType > void createConstraint ( string const & constraintName );
 
 
  MinimumBHPConstraint * getMinBHPConstraint() { return m_minBHPConstraint; };
  MinimumBHPConstraint * getMinBHPConstraint() const { return m_minBHPConstraint; };
  MaximumBHPConstraint * getMaxBHPConstraint() { return m_maxBHPConstraint; };
  MaximumBHPConstraint * getMaxBHPConstraint() const { return m_maxBHPConstraint; };
  // Lists of rate constraints
  std::vector< WellConstraintBase * >  getProdRateConstraints() { return m_productionRateConstraintList; };
  std::vector< WellConstraintBase * >  getProdRateConstraints() const { return m_productionRateConstraintList; };
  std::vector< WellConstraintBase * >  getInjRateConstraints() { return m_injectionRateConstraintList; }
  std::vector< WellConstraintBase * >  getInjRateConstraints() const { return m_injectionRateConstraintList; }
protected:
 
  virtual void postInputInitialization() override;
 
 
 
private:
 
  Type m_type;
 
  real64 m_refElevation;
 
  real64 m_refGravCoef;
 
  Control m_currentControl;
 
  integer m_useSurfaceConditions;
 
  // Fuild model to compute properties for constraint equation user specified conditions
  std::unique_ptr< constitutive::ConstitutiveBase >  m_fluidSeparatorPtr;
 
  string m_referenceReservoirRegion;
 
  real64 m_surfacePres;
 
  real64 m_surfaceTemp;
 
 
  string m_statusTableName;
 
  string m_perfStatusTableName;
 
  integer m_isCrossflowEnabled;
 
  real64 m_initialPressureCoefficient;
 
  real64 m_rateSign;
 
 
  TableFunction const * m_statusTable;
 
  bool m_wellOpen;
 
  integer m_estimateSolution;
 
  //constraint_array m_ConstraintList;
  // Bool to trigger old/new constraint switch logic
  bool m_constraintSwitch;
 
  // Current constraint
  WellConstraintBase * m_currentConstraint;
  // Minimum and maximum BHP and WHP constraints
  MinimumBHPConstraint *  m_minBHPConstraint;
  MaximumBHPConstraint * m_maxBHPConstraint;
 
 
  // Lists of rate constraints
  std::vector< WellConstraintBase * > m_productionRateConstraintList;
  std::vector< WellConstraintBase * > m_injectionRateConstraintList;
 
 
  WellControls::Status m_wellStatus;
 
 
  real64 m_regionAveragePressure;
 
  real64 m_regionAverageTemperature;
 
};
 
 
// Use local aliases to avoid accidental macro expansion of the tokens 'Type' or 'Control'
using WellControls_Type = WellControls::Type;
ENUM_STRINGS( WellControls_Type,
              "producer",
              "injector" );
 
using WellControls_Control = WellControls::Control;
ENUM_STRINGS( WellControls_Control,
              "BHP",
              "phaseVolRate",
              "totalVolRate",
              "massRate",
              "uninitialized" );
 
 
} //namespace geos
 
#endif //GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLCONTROLS_HPP