WellsGroup.hpp

Go to the documentation of this file.

/*
  Copyright 2012 SINTEF ICT, Applied Mathematics.
 
  This file is part of the Open Porous Media project (OPM).
 
  OPM is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  OPM is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef OPM_WELLSGROUP_HPP
#define OPM_WELLSGROUP_HPP
 
#include <opm/core/wells/InjectionSpecification.hpp>
#include <opm/core/wells/ProductionSpecification.hpp>
#include <opm/core/grid.h>
#include <opm/core/props/BlackoilPhases.hpp>
 
#include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Group.hpp>
 
#include <string>
#include <memory>
 
namespace Opm
{
    // Need to forward declare this one, some of the methods in the base
    // class returns pointers to it.
    class WellNode;
 
    struct WellPhasesSummed
    {
        WellPhasesSummed();
        double res_inj_rates[3];
        double res_prod_rates[3];
        double surf_inj_rates[3];
        double surf_prod_rates[3];
 
        void operator+=(const WellPhasesSummed& other);
    };
 
    class WellsGroupInterface
    {
    public:
        WellsGroupInterface(const std::string& name,
                            const double efficiency_factor,
                            const ProductionSpecification& prod_spec,
                            const InjectionSpecification& inj_spec,
                            const PhaseUsage& phase_usage);
        virtual ~WellsGroupInterface();
 
        const std::string& name() const;
 
        const ProductionSpecification& prodSpec() const;
 
        const InjectionSpecification& injSpec() const;
 
        ProductionSpecification& prodSpec();
 
        InjectionSpecification& injSpec();
 
        const PhaseUsage& phaseUsage() const;
 
        virtual bool isLeafNode() const;
 
        virtual WellsGroupInterface* findGroup(const std::string& name_of_node) = 0;
 
        void setParent(WellsGroupInterface* parent);
 
        const WellsGroupInterface* getParent() const;
 
        WellsGroupInterface* getParent();
 
        virtual int numberOfLeafNodes() = 0;
 
        virtual bool conditionsMet(const std::vector<double>& well_bhp,
                                   const std::vector<double>& well_reservoirrates_phase,
                                   const std::vector<double>& well_surfacerates_phase,
                                   WellPhasesSummed& summed_phases) = 0;
 
        //                           otherwise, all children will be set under group control
        virtual void applyInjGroupControl(const InjectionSpecification::ControlMode control_mode,
                                          const InjectionSpecification::InjectorType injector_type,
                                          const double target,
                                          const bool only_group) = 0;
        //                           otherwise, all children will be set under group control
        virtual void applyProdGroupControl(const ProductionSpecification::ControlMode control_mode,
                                           const double target,
                                           const bool only_group) = 0;
 
        virtual std::pair<WellNode*, double> getWorstOffending(const std::vector<double>& well_reservoirrates_phase,
                                                               const std::vector<double>& well_surfacerates_phase,
                                                               ProductionSpecification::ControlMode mode) = 0;
 
        double getTarget(ProductionSpecification::ControlMode mode) const;
 
        double getTarget(InjectionSpecification::ControlMode mode) const;
 
        virtual void applyProdGroupControls() = 0;
 
        virtual void applyInjGroupControls() = 0;
 
        virtual double productionGuideRate(bool only_group) = 0;
 
        virtual double injectionGuideRate(bool only_group) = 0;
 
        virtual double getTotalProductionFlow(const std::vector<double>& phase_flows,
                                              const BlackoilPhases::PhaseIndex phase) const = 0;
 
        virtual void applyExplicitReinjectionControls(const std::vector<double>& well_reservoirrates_phase,
                                                      const std::vector<double>& well_surfacerates_phase) = 0;
 
        virtual void applyVREPGroupControls(const std::vector<double>& well_voidage_rates,
                                            const std::vector<double>& conversion_coeffs) = 0;
 
        virtual void applyVREPGroupControl(const double target,
                                           const InjectionSpecification::InjectorType injector_type,
                                           const std::vector<double>& well_voidage_rates,
                                           const std::vector<double>& conversion_coeffs,
                                           const bool only_group) = 0;
 
        virtual double getTotalVoidageRate(const std::vector<double>& well_voidage_rates) = 0;
 
        bool individualControl() const;
 
        void setIndividualControl(const bool);
 
        virtual double getProductionRate(const std::vector<double>& well_rates,
                                         const ProductionSpecification::ControlMode prod_mode) const = 0;
 
        virtual void updateWellProductionTargets(const std::vector<double>& well_rates) = 0;
 
        virtual void updateWellInjectionTargets(const std::vector<double>& well_rates) = 0;
 
        virtual void setTargetUpdated(const bool flag) = 0;
 
        // bascially, for the group or wells under group control
        // they have the potential to adjust their targets to produce more to match the higher level target
        virtual bool canProduceMore() const = 0;
 
        // checking wether group production target converged
        // if the group is producing following the target, then it should be considered okay
        // if the group is not producing following the target, then we should check wether the group
        // should be able to produce more to match the target.
        // if the group can not produce more, we also consider the effort to match the group target is
        // also done and the group target converged while we should give a message
        virtual bool groupProdTargetConverged(const std::vector<double>& well_rates) const = 0;
 
        double efficiencyFactor() const;
 
        void setEfficiencyFactor(const double efficiency_factor);
 
    protected:
        double rateByMode(const double* res_rates,
                          const double* surf_rates,
                          const ProductionSpecification::ControlMode mode);
 
        double rateByMode(const double* res_rates,
                          const double* surf_rates,
                          const InjectionSpecification::ControlMode mode);
 
        WellsGroupInterface* parent_;
 
        // Whether well is running under the group control target.
        // Current only consider one level of control.
        // So not putting it in the WellsGroupInterface yet.
        bool individual_control_;
 
        // Efficiency factor
        double efficiency_factor_;
 
    private:
        std::string name_;
        ProductionSpecification production_specification_;
        InjectionSpecification injection_specification_;
        PhaseUsage phase_usage_;
    };
 
 
 
    class WellsGroup : public WellsGroupInterface
    {
    public:
        WellsGroup(const std::string& name,
                   const double efficiency_factor,
                   const ProductionSpecification& prod_spec,
                   const InjectionSpecification& inj_spec,
                   const PhaseUsage& phase_usage);
 
        virtual WellsGroupInterface* findGroup(const std::string& name_of_node);
 
        void addChild(std::shared_ptr<WellsGroupInterface> child);
 
        virtual bool conditionsMet(const std::vector<double>& well_bhp,
                                   const std::vector<double>& well_reservoirrates_phase,
                                   const std::vector<double>& well_surfacerates_phase,
                                   WellPhasesSummed& summed_phases);
 
        virtual int numberOfLeafNodes();
        virtual std::pair<WellNode*, double> getWorstOffending(const std::vector<double>& well_reservoirrates_phase,
                                                               const std::vector<double>& well_surfacerates_phase,
                                                               ProductionSpecification::ControlMode mode);
 
        //                           otherwise, all children will be set under group control
        virtual void applyInjGroupControl(const InjectionSpecification::ControlMode control_mode,
                                          const InjectionSpecification::InjectorType injector_type,
                                          const double target,
                                          bool only_group);
 
        //                           otherwise, all children will be set under group control
        virtual void applyProdGroupControl(const ProductionSpecification::ControlMode control_mode,
                                           const double target,
                                           bool only_group);
 
        virtual void applyProdGroupControls();
 
        virtual void applyInjGroupControls();
 
        virtual double productionGuideRate(bool only_group);
 
        virtual double injectionGuideRate(bool only_group);
 
        virtual double getTotalProductionFlow(const std::vector<double>& phase_flows,
                                              const BlackoilPhases::PhaseIndex phase) const;
 
        virtual void applyExplicitReinjectionControls(const std::vector<double>& well_reservoirrates_phase,
                                                      const std::vector<double>& well_surfacerates_phase);
 
        virtual void applyVREPGroupControls(const std::vector<double>& well_voidage_rates,
                                            const std::vector<double>& conversion_coeffs);
 
        virtual void applyVREPGroupControl(const double target,
                                           const InjectionSpecification::InjectorType injector_type,
                                           const std::vector<double>& well_voidage_rates,
                                           const std::vector<double>& conversion_coeffs,
                                           const bool only_group);
 
        virtual double getTotalVoidageRate(const std::vector<double>& well_voidage_rates);
 
        virtual void updateWellProductionTargets(const std::vector<double>& well_rates);
 
        virtual void updateWellInjectionTargets(const std::vector<double>& well_rates);
 
        virtual void setTargetUpdated(const bool flag);
 
        virtual double getProductionRate(const std::vector<double>& well_rates,
                                         const ProductionSpecification::ControlMode prod_mode) const;
 
        virtual bool canProduceMore() const;
 
        virtual bool groupProdTargetConverged(const std::vector<double>& well_rates) const;
 
    private:
        std::vector<std::shared_ptr<WellsGroupInterface> > children_;
    };
 
 
 
    class WellNode : public WellsGroupInterface
    {
    public:
        WellNode(const std::string& name,
                 const double efficiency_factor,
                 const ProductionSpecification& prod_spec,
                 const InjectionSpecification& inj_spec,
                 const PhaseUsage& phase_usage);
 
        virtual WellsGroupInterface* findGroup(const std::string& name_of_node);
        virtual bool conditionsMet(const std::vector<double>& well_bhp,
                                   const std::vector<double>& well_reservoirrates_phase,
                                   const std::vector<double>& well_surfacerates_phase,
                                   WellPhasesSummed& summed_phases);
 
        virtual bool isLeafNode() const;
 
        void setWellsPointer(Wells* wells, int self_index);
 
        virtual int numberOfLeafNodes();
 
        // Shuts the well (in the well struct)
        void shutWell();
 
       virtual std::pair<WellNode*, double> getWorstOffending(const std::vector<double>& well_reservoirrates_phase,
                                                               const std::vector<double>& well_surfacerates_phase,
                                                               ProductionSpecification::ControlMode mode);
 
        virtual void applyInjGroupControl(const InjectionSpecification::ControlMode control_mode,
                                          const InjectionSpecification::InjectorType injector_type,
                                          const double target,
                                          bool only_group);
 
        virtual void applyProdGroupControl(const ProductionSpecification::ControlMode control_mode,
                                           const double target,
                                           bool only_group);
 
        virtual void applyProdGroupControls();
 
        virtual void applyInjGroupControls();
 
        virtual double productionGuideRate(bool only_group);
 
        virtual double injectionGuideRate(bool only_group);
 
        virtual double getTotalProductionFlow(const std::vector<double>& phase_flows,
                                              const BlackoilPhases::PhaseIndex phase) const;
 
        WellType type() const;
 
        virtual void applyExplicitReinjectionControls(const std::vector<double>& well_reservoirrates_phase,
                                                      const std::vector<double>& well_surfacerates_phase);
 
        virtual void applyVREPGroupControls(const std::vector<double>& well_voidage_rates,
                                            const std::vector<double>& conversion_coeffs);
 
        virtual void applyVREPGroupControl(const double target,
                                           const InjectionSpecification::InjectorType injector_type,
                                           const std::vector<double>& well_voidage_rates,
                                           const std::vector<double>& conversion_coeffs,
                                           const bool only_group);
 
        virtual double getTotalVoidageRate(const std::vector<double>& well_voidage_rates);
 
        int groupControlIndex() const;
 
        virtual double getProductionRate(const std::vector<double>& well_rates,
                                         const ProductionSpecification::ControlMode prod_mode) const;
 
        virtual void updateWellProductionTargets(const std::vector<double>& well_rates);
 
        virtual void updateWellInjectionTargets(const std::vector<double>& well_rates);
 
        double getAccumulativeEfficiencyFactor() const;
 
        bool isProducer() const;
 
        bool isInjector() const;
 
        int selfIndex() const;
 
        bool targetUpdated() const;
 
        bool isGuideRateWellPotential() const;
 
        void setIsGuideRateWellPotential(const bool flag);
 
        virtual void setTargetUpdated(const bool flag);
 
        virtual bool canProduceMore() const;
 
        virtual bool groupProdTargetConverged(const std::vector<double>& well_rates) const;
 
    private:
        Wells* wells_;
        int self_index_;
        int group_control_index_;
        bool shut_well_;
        // TODO: used when updating well targets
        bool target_updated_;
        // whether the guide rate is specified with well potential
        // TODO: we have never handle the guide rates for groups, maybe this
        // is something will go to WellsGroupInterface later
        bool is_guiderate_wellpotential_;
    };
 
    std::shared_ptr<WellsGroupInterface> createWellWellsGroup(const Well* well, size_t timeStep,
                                                              const PhaseUsage& phase_usage );
 
    std::shared_ptr<WellsGroupInterface> createGroupWellsGroup(const Group& group, size_t timeStep,
                                                               const PhaseUsage& phase_usage );
}
 
#endif  /* OPM_WELLSGROUP_HPP */