well_results_storage.h

Go to the documentation of this file.

#ifndef __BS_WELL_RESULTS_STORAGE_H
#define __BS_WELL_RESULTS_STORAGE_H

#include "well_rate_control.h"
#include "apply_wefac.h"
#include "rate_control_type.h"
#include "fi_params.h"
//#include "well_connection.h"

namespace blue_sky
  {

  enum well_d_params
  {
    WELL_D_PARAM_COR = 0,         
    WELL_D_PARAM_CWR,             
    WELL_D_PARAM_CGR,             
    WELL_D_PARAM_CLR,             
    WELL_D_PARAM_COI,             
    WELL_D_PARAM_CWI,             
    WELL_D_PARAM_CGI,             

    WELL_D_PARAM_HCOR,            
    WELL_D_PARAM_HCWR,            
    WELL_D_PARAM_HCGR,            
    WELL_D_PARAM_HCLR,            
    WELL_D_PARAM_HCOI,            
    WELL_D_PARAM_HCWI,            
    WELL_D_PARAM_HCGI,            

    WELL_D_PARAM_CBHP,            
    WELL_D_PARAM_HBHP,            

    WELL_D_PARAM_TOR,             
    WELL_D_PARAM_TWR,             
    WELL_D_PARAM_TGR,             
    WELL_D_PARAM_TLR,             
    WELL_D_PARAM_TOI,             
    WELL_D_PARAM_TWI,             
    WELL_D_PARAM_TGI,             

    WELL_D_PARAM_HTOR,            
    WELL_D_PARAM_HTWR,            
    WELL_D_PARAM_HTGR,            
    WELL_D_PARAM_HTLR,            
    WELL_D_PARAM_HTOI,            
    WELL_D_PARAM_HTWI,            
    WELL_D_PARAM_HTGI,            
    WELL_D_PARAM_WEFAC,           
    WELL_D_PARAM_WBP1,            
    WELL_D_PARAM_WBP4,            
    WELL_D_PARAM_WBP5,            
    WELL_D_PARAM_WBP9,            

    // should be the last
    WELL_D_PARAM_COUNT
  };

  enum conn_d_params
  {
    CONN_D_PARAM_COR = 0,         
    CONN_D_PARAM_CWR,             
    CONN_D_PARAM_CGR,             
    CONN_D_PARAM_CLR,             
    CONN_D_PARAM_COI,             
    CONN_D_PARAM_CWI,             
    CONN_D_PARAM_CGI,             
    CONN_D_PARAM_BHP,             
    CONN_D_PARAM_BULKP,           
    CONN_D_PARAM_TOR,             
    CONN_D_PARAM_TWR,             
    CONN_D_PARAM_TGR,             
    CONN_D_PARAM_TLR,             
    CONN_D_PARAM_TOI,             
    CONN_D_PARAM_TWI,             
    CONN_D_PARAM_TGI,             
    CONN_D_PARAM_FACTOR,          
    CONN_D_PARAM_DEPTH,           

    // should be the last
    CONN_D_PARAM_COUNT
  };

  enum conn_i_params
  {
    CONN_I_PARAM_STATUS = 0,      
    CONN_I_PARAM_GRP_STATUS,      
    CONN_I_PARAM_I,               
    CONN_I_PARAM_J,               
    CONN_I_PARAM_K1,              
    CONN_I_PARAM_K2,              
    CONN_I_PARAM_NBLOCK,          

    // should be the last
    CONN_I_PARAM_COUNT
  };

  enum well_i_params
  {
    WELL_I_PARAM_HSTATUS = 0,
    WELL_I_PARAM_STATUS,

    // should be the last
    WELL_I_PARAM_COUNT
  };

  class BS_API_PLUGIN connection_results
    {
      // methods
    public:
      connection_results ();
      ~connection_results ();

      void
      clear ();

      // variables
    public:
      typedef std::vector<double>                 dates_type;
      typedef std::vector<float>                  d_params_internal_type;
      typedef std::vector<d_params_internal_type> d_params_type;
      typedef std::vector<int>                    i_params_internal_type;
      typedef std::vector<i_params_internal_type> i_params_type;

      dates_type dates;                           
      d_params_type d_params;                     
      i_params_type i_params;                     
    };

  class BS_API_PLUGIN well_results
    {
      // methods
    public:
      well_results ();
      ~well_results ();

      void
      clear ();

      // variables
    public:
      typedef std::vector<double>                 dates_type;
      typedef std::vector<float>                  d_params_internal_type;
      typedef std::vector<d_params_internal_type> d_params_type;
      typedef std::vector<int>                    i_params_internal_type;
      typedef std::vector<i_params_internal_type> i_params_type;
      typedef std::map<int, connection_results>   conn_type;
      typedef std::pair<int, connection_results>  conn_pair_type;

      conn_type connections;
      dates_type dates;
      d_params_type d_params;
      i_params_type i_params;
      std::string group;
    };

  class BS_API_PLUGIN well_results_storage : public objbase
    {
      BLUE_SKY_TYPE_DECL (well_results_storage);
      // methods
    public:
      ~well_results_storage ();

      // variables
    public:
      typedef std::map<std::string, well_results>   wells_type;
      typedef std::pair<std::string, well_results>  wells_pair_type;

      wells_type wells;
    };


  template <typename strategy_t>
  struct save_well_data
    {
      typedef calc_model <strategy_t>                                 calc_model_t;
      typedef typename strategy_t::index_t                            index_t;

      typedef typename calc_model_t::data_array_t                     data_array_t;
      typedef typename calc_model_t::item_t                           item_t;
      typedef typename calc_model_t::connection_t                     connection_t;
      typedef typename calc_model_t::well_t                           well_t;
      typedef typename calc_model_t::strategy_type                    strategy_type;

      typedef smart_ptr <calc_model_t, true>                          sp_calc_model_t;
      typedef typename calc_model_t::sp_well_t                        sp_well_t;
      typedef typename calc_model_t::sp_connection_t                  sp_connection_t;
      typedef smart_ptr<well_results_storage, true>                   sp_well_results_storage;

      typedef typename calc_model_t::reservoir_t::facility_manager_t  facility_manager_t;
      typedef typename facility_manager_t::well_const_iterator_t      well_iterator_t;

      void
      copy_well_data_to_storage (sp_calc_model_t &calc_model, item_t /*dt*/, well_iterator_t wb, const well_iterator_t &we, size_t /*iter_counter*/, item_t time)
      {
        const sp_well_results_storage &w_res (calc_model->well_res);

        //TODO: groups
        for (well_iterator_t well = wb; well != we; ++well)
          {
            sp_well_t ws (well->second, bs_dynamic_cast ());
            well_results &wr = w_res->wells[ws->get_name ()];

            wr.group = std::string ("FIELD");//TODO ws->get_group_name ()
            // add time value
            wr.dates.push_back (time);

            // add current rates
            wr.d_params[WELL_D_PARAM_COR].push_back (-(float)ws->rate ().prod.oil);
            wr.d_params[WELL_D_PARAM_CWR].push_back (-(float)ws->rate ().prod.water);
            wr.d_params[WELL_D_PARAM_CGR].push_back (-(float)ws->rate ().prod.gas);
            wr.d_params[WELL_D_PARAM_CLR].push_back (-(float)ws->rate ().prod.liquid);
            wr.d_params[WELL_D_PARAM_COI].push_back ((float)ws->rate ().inj.oil);
            wr.d_params[WELL_D_PARAM_CWI].push_back ((float)ws->rate ().inj.water);
            wr.d_params[WELL_D_PARAM_CGI].push_back ((float)ws->rate ().inj.gas);


            // add initial rates
            wr.d_params[WELL_D_PARAM_HCOR].push_back (0);
            wr.d_params[WELL_D_PARAM_HCWR].push_back (0);
            wr.d_params[WELL_D_PARAM_HCGR].push_back (0);
            wr.d_params[WELL_D_PARAM_HCLR].push_back (0);
            wr.d_params[WELL_D_PARAM_HCOI].push_back (0);
            wr.d_params[WELL_D_PARAM_HCWI].push_back (0);
            wr.d_params[WELL_D_PARAM_HCGI].push_back (0);

            wr.d_params[WELL_D_PARAM_TOR].push_back (-(float)ws->rate_total ().prod.oil);
            wr.d_params[WELL_D_PARAM_TWR].push_back (-(float)ws->rate_total ().prod.water);
            wr.d_params[WELL_D_PARAM_TGR].push_back (-(float)ws->rate_total ().prod.gas);
            wr.d_params[WELL_D_PARAM_TLR].push_back (-(float)ws->rate_total ().prod.liquid);
            wr.d_params[WELL_D_PARAM_TOI].push_back ((float)ws->rate_total ().inj.oil);
            wr.d_params[WELL_D_PARAM_TWI].push_back ((float)ws->rate_total ().inj.water);
            wr.d_params[WELL_D_PARAM_TGI].push_back ((float)ws->rate_total ().inj.gas);

            /*          //TODO
                        wr.d_params[WELL_D_PARAM_HTOR].push_back (-(float)ws->total_initial_rate.oil);
                        wr.d_params[WELL_D_PARAM_HTWR].push_back (-(float)ws->total_initial_rate.water);
                        wr.d_params[WELL_D_PARAM_HTGR].push_back (-(float)ws->total_initial_rate.gas);
                        wr.d_params[WELL_D_PARAM_HTLR].push_back ((float)ws->total_initial_rate.liquid);
                        wr.d_params[WELL_D_PARAM_HTOI].push_back ((float)ws->total_initial_rate.oil_inj);
                        wr.d_params[WELL_D_PARAM_HTWI].push_back ((float)ws->total_initial_rate.water_inj);
                        wr.d_params[WELL_D_PARAM_HTGI].push_back ((float)ws->total_initial_rate.gas_inj);
                        wr.d_params[WELL_D_PARAM_WEFAC].push_back ((float)ws->wefac);
            */

            wr.d_params[WELL_D_PARAM_CBHP].push_back ((float)ws->get_well_controller ()->bhp ());
            wr.d_params[WELL_D_PARAM_HBHP].push_back ((float)ws->get_well_controller ()->bhp_history ());

            // add integer information
            using namespace wells;
            int status = -999, producer = 0;
            if (ws->get_well_controller ()->is_production ())
              producer = 1;
            rate_control_type control_type = ws->get_well_controller ()->get_control_type ();
            if (!ws->is_open ())
              {
                status = 0;
              }
            else if (control_type == bhp_control)
              {
                if (producer)
                  status = -2;
                else
                  status = 2;
              }
            else if (control_type == oil_rate_control) // (assume is producer)
              {
                status = -4;
              }
            else if (control_type == water_rate_control)
              {
                if (producer)
                  status = -3;
                else
                  status = 1;
              }
            else if (control_type == gas_rate_control) // (assume is producer)
              {
                status = -5;
              }
            else if (control_type == rate_control) // (assume is injector)
              {
                status = 3;
              }
            else if (control_type == liquid_rate_control)// (assume is producer)
              {
                status = -1;
              }

            wr.i_params[WELL_I_PARAM_HSTATUS].push_back (0);//TODO
            wr.i_params[WELL_I_PARAM_STATUS].push_back (status);

            if (calc_model->ts_params->get_bool (fi_params::WRITE_CONN_RESULTS_TO_HDF5))
              {
                for (size_t i = 0, cnt = ws->get_connections_count (); i < cnt; ++i)
                  {
                    const sp_connection_t &ci = ws->get_connection (i);
                    int cell = ci->n_block ();
                    connection_results &cr = wr.connections[cell];
                    cr.dates.push_back (time);

                    if (!ci->is_shut ())
                      {/*
                                                //TODO
                                                cr.d_params[CONN_D_PARAM_COR].push_back (-(float)ci->second.rate.water);
                                                cr.d_params[CONN_D_PARAM_CWR].push_back (-(float)ci->second.rate.water);
                                                cr.d_params[CONN_D_PARAM_CGR].push_back (-(float)ci->second.rate.gas);
                                                cr.d_params[CONN_D_PARAM_CLR].push_back (-(float)ci->second.rate.liquid);
                                                cr.d_params[CONN_D_PARAM_COI].push_back ((float)ci->second.rate.oil_inj);
                                                cr.d_params[CONN_D_PARAM_CWI].push_back ((float)ci->second.rate.water_inj);
                                                cr.d_params[CONN_D_PARAM_CGI].push_back ((float)ci->second.rate.gas_inj);
                                                */
                      }
                    else
                      {
                        cr.d_params[CONN_D_PARAM_COR].push_back (0);
                        cr.d_params[CONN_D_PARAM_CWR].push_back (0);
                        cr.d_params[CONN_D_PARAM_CGR].push_back (0);
                        cr.d_params[CONN_D_PARAM_CLR].push_back (0);
                        cr.d_params[CONN_D_PARAM_COI].push_back (0);
                        cr.d_params[CONN_D_PARAM_CWI].push_back (0);
                        cr.d_params[CONN_D_PARAM_CGI].push_back (0);
                      }

                    cr.d_params[CONN_D_PARAM_FACTOR].push_back ((float)ci->get_fact ());
                    cr.d_params[CONN_D_PARAM_BHP].push_back ((float)ci->get_cur_bhp ());
                    cr.d_params[CONN_D_PARAM_BULKP].push_back ((float)ci->get_bulkp ());
                    cr.d_params[CONN_D_PARAM_DEPTH].push_back ((float)ci->connection_depth);

                    cr.i_params[CONN_I_PARAM_STATUS].push_back (ci->get_status ());
                    cr.i_params[CONN_I_PARAM_GRP_STATUS].push_back (0);//TODO
                    cr.i_params[CONN_I_PARAM_I].push_back (ci->i_coord ());
                    cr.i_params[CONN_I_PARAM_J].push_back (ci->j_coord ());
                    cr.i_params[CONN_I_PARAM_K1].push_back (ci->k_coord ());
                    cr.i_params[CONN_I_PARAM_K2].push_back (ci->k_coord ());

                    /*                  //TODO
                                        cr.d_params[CONN_D_PARAM_TOR].push_back (-(float)ci->second.commulative_rate.oil);
                                        cr.d_params[CONN_D_PARAM_TWR].push_back (-(float)ci->second.commulative_rate.water);
                                        cr.d_params[CONN_D_PARAM_TGR].push_back (-(float)ci->second.commulative_rate.gas);
                                        cr.d_params[CONN_D_PARAM_TLR].push_back (-(float)ci->second.commulative_rate.liquid);
                                        cr.d_params[CONN_D_PARAM_TOI].push_back ((float)ci->second.commulative_rate.oil_inj);
                                        cr.d_params[CONN_D_PARAM_TWI].push_back ((float)ci->second.commulative_rate.water_inj);
                                        cr.d_params[CONN_D_PARAM_TGI].push_back ((float)ci->second.commulative_rate.gas_inj);
                    */
                  }

              }
          }
      }
    };

} //blue_sky
#endif //__BS_WELL_RESULTS_STORAGE_H

---