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 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;

        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;

        virtual void applyInjGroupControl(const InjectionSpecification::ControlMode control_mode,
                                          const double target,
                                          const bool forced) = 0;
        virtual void applyProdGroupControl(const ProductionSpecification::ControlMode control_mode,
                                           const double target,
                                           const bool forced) = 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);

        double getTarget(InjectionSpecification::ControlMode mode);

        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) = 0;

        virtual void applyExplicitReinjectionControls(const std::vector<double>& well_reservoirrates_phase,
                                                      const std::vector<double>& well_surfacerates_phase) = 0;


    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_;

    private:
        std::string name_;
        ProductionSpecification production_specification_;
        InjectionSpecification injection_specification_;
        PhaseUsage phase_usage_;
    };



    class WellsGroup : public WellsGroupInterface
    {
    public:
        WellsGroup(const std::string& name,
                   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);

        virtual void applyInjGroupControl(const InjectionSpecification::ControlMode control_mode,
                                          const double target,
                                          bool forced);

        virtual void applyProdGroupControl(const ProductionSpecification::ControlMode control_mode,
                                           const double target,
                                           bool forced);

        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);

        virtual void applyExplicitReinjectionControls(const std::vector<double>& well_reservoirrates_phase,
                                                      const std::vector<double>& well_surfacerates_phase);

    private:
        std::vector<std::shared_ptr<WellsGroupInterface> > children_;
    };



    class WellNode : public WellsGroupInterface
    {
    public:
        WellNode(const std::string& name,
                 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 double target,
                                          bool forced);

        virtual void applyProdGroupControl(const ProductionSpecification::ControlMode control_mode,
                                           const double target,
                                           bool forced);

        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);

        WellType type() const;

        virtual void applyExplicitReinjectionControls(const std::vector<double>& well_reservoirrates_phase,
                                                      const std::vector<double>& well_surfacerates_phase);

    private:
        Wells* wells_;
        int self_index_;
        int group_control_index_;
        bool shut_well_;
    };

    std::shared_ptr<WellsGroupInterface> createWellWellsGroup(WellConstPtr well, size_t timeStep,
                                                              const PhaseUsage& phase_usage );

    std::shared_ptr<WellsGroupInterface> createGroupWellsGroup(GroupConstPtr group, size_t timeStep,
                                                               const PhaseUsage& phase_usage );
}
#endif  /* OPM_WELLSGROUP_HPP */