quantity_wrappers.hpp

Go to the documentation of this file.

#ifndef LIBVIENNASHE_QUANTITY_WRAPPERS_HPP
#define LIBVIENNASHE_QUANTITY_WRAPPERS_HPP
/* ============================================================================
   Copyright (c) 2011-2022, Institute for Microelectronics,
                            Institute for Analysis and Scientific Computing,
                            TU Wien.
 
                            -----------------
     ViennaSHE - The Vienna Spherical Harmonics Expansion Boltzmann Solver
                            -----------------
 
                    http://viennashe.sourceforge.net/
 
   License:         MIT (X11), see file LICENSE in the base directory
=============================================================================== */
 
 
// ++++++++++++++++++++++++++++++++++++
//
// +++++++++++   C++ ONLY   +++++++++++
//
// ++++++++++++++++++++++++++++++++++++
 
#include <iostream>
#include <cstdlib>
#include <vector>
 
#include "viennashe/forwards.h"
#include "viennashe/exception.hpp"
 
#include "libviennashe/src/viennashe_all.hpp"
 
 
namespace libviennashe
{
  namespace quantity
  {
    class quantity_wrapper
    {
    public:
      quantity_wrapper(std::string name) : name_(name) {}
 
      quantity_wrapper() : name_("") {}
 
      quantity_wrapper(quantity_wrapper const & v) : name_(v.name_) {}
      virtual ~quantity_wrapper() {}
 
      void operator=(quantity_wrapper const & o) { this->name_ = o.name_; }
 
      virtual void fill(double ** values, viennashe_index_type * len) const = 0;
 
      virtual void fill_single (std::size_t idx, std::vector<double> & values) const  = 0;
 
      virtual quantity_wrapper * copy() const = 0;
 
      std::string name() const { return this->name_; }
 
    protected:
      void set_name(std::string const & n) { this->name_ = n; }
 
    private:
      std::string name_;
    };
 
    template <typename DeviceT, typename AccessorT, typename ElementTagT >
    class accessor_based_quantity_wrapper : public quantity_wrapper
    {
    public:
 
      typedef accessor_based_quantity_wrapper<DeviceT, AccessorT, ElementTagT> self_type;
 
      accessor_based_quantity_wrapper(AccessorT const & acc,
        DeviceT const & dev,
        std::string name)
        : quantity_wrapper(name), dev_(dev), acc_(acc)
      { }
 
      accessor_based_quantity_wrapper(accessor_based_quantity_wrapper const & o)
        : quantity_wrapper(o), dev_(o.dev_), acc_(o.acc_)
      { }
 
      void operator=(accessor_based_quantity_wrapper const & o)
      {
        this->set_name(o.name());
        dev_(o.dev_); acc_(o.acc_);
      }
 
      double get(std::size_t id) const
      {
        return acc_(viennagrid::elements<ElementTagT>(dev_.mesh())[id]);
      }
 
      virtual void fill(double ** values, viennashe_index_type * len) const
      {
        const std::size_t num = viennagrid::elements<ElementTagT>(dev_.mesh()).size();
 
        for (std::size_t i = 0; i < num; ++i)
        {
          values[i] = new double(); // The user has to clear things up
          values[i][0] = this->get(i);
          len[i] = 1;
        }
      }
 
      virtual void fill_single(std::size_t idx, std::vector<double> & values) const
      {
        values.resize(1);
        values[0] = this->get(idx);
      }
 
      virtual quantity_wrapper * copy() const { return new self_type(*this); }
 
    private:
      DeviceT   const & dev_;
      AccessorT acc_;
    };
 
    template <typename DeviceT, typename AccessorT, typename ElementTagT >
    class accessor_based_array_quantity_wrapper : public quantity_wrapper
    {
    public:
 
      typedef accessor_based_array_quantity_wrapper<DeviceT, AccessorT, ElementTagT> self_type;
 
      accessor_based_array_quantity_wrapper(AccessorT const & acc,
        DeviceT const & dev,
        std::string name)
        : quantity_wrapper(name), dev_(dev), acc_(acc)
      { }
 
      accessor_based_array_quantity_wrapper(accessor_based_array_quantity_wrapper const & o)
        : quantity_wrapper(o), dev_(o.dev_), acc_(o.acc_)
      { }
 
      void operator=(accessor_based_array_quantity_wrapper const & o)
      {
        this->set_name(o.name());
        dev_(o.dev_); acc_(o.acc_);
      }
 
      std::vector<double> get(std::size_t id) const
      {
        return acc_(viennagrid::elements<ElementTagT>(dev_.mesh())[id]);
      }
 
      virtual void fill_single(std::size_t idx, std::vector<double> & values) const { values = this->get(idx); }
 
      virtual void fill(double ** values, viennashe_index_type * len) const
      {
        const std::size_t num = viennagrid::elements<ElementTagT>(dev_.mesh()).size();
 
        for (std::size_t i = 0; i < num; ++i)
        {
          const std::vector<double> valuevector = this->get(i);
          const std::size_t current_length = valuevector.size();
 
          values[i] = new double[current_length]; // The user has to clear things up
 
          for (std::size_t j = 0; j < current_length; ++j) values[i][j] = valuevector.at(j);
 
          len[i] = static_cast<viennashe_index_type>(current_length);
        }
      }
 
      virtual quantity_wrapper * copy() const { return new self_type(*this); }
 
    private:
      DeviceT   const & dev_;
      AccessorT acc_;
    };
 
    class quantitiy_register
    {
    public:
      typedef std::map<std::string, quantity_wrapper * > quan_map;
 
      virtual ~quantitiy_register()
      {
        for (quan_map::iterator it = quans_.begin(); it != quans_.end(); ++it)
        {
         if (it->second != NULL)
           delete it->second;
         it->second = NULL;
        }
      }
 
      std::size_t size() const { return this->quans_.size(); }
 
      std::vector<std::string> get_names() const
      {
        std::vector<std::string> v;
        for (quan_map::const_iterator it = quans_.begin(); it != quans_.end(); ++it)
        {
          v.push_back(it->first);
        }
        return v;
      }
 
      quantity_wrapper const & get(std::string const & name) const { return *(quans_.at(name)); }
 
      bool has_quan(std::string const & name) const { return (this->quans_.find(name) != this->quans_.end()); }
 
      void register_quan(quantity_wrapper const & quan)
      {
        std::string name = quan.name();
        if (this->has_quan(name))
        {
          viennashe::log::error() << "ERROR: ViennaSHE C/C++ Wrappers failed! Where? Quantitiy Management at register_quan for '"
                                  << name << "', which is already registered!" << std::endl;
          throw std::runtime_error("Quantitiy already exists");
        }
        else
        {
          this->quans_.insert(std::make_pair(name, quan.copy()));
        }
      }
 
    private:
      quan_map quans_;
    }; // quantity_register
 
 
  } // namespace quantity
 
  struct quan_register_internal
  {
 
    quan_register_internal() : int_sim(NULL) { }
 
    std::size_t count() const
    {
      return cell_based.size() ;
    }
 
    libviennashe::quantity::quantitiy_register cell_based; 
 
    viennashe_simulator_impl * int_sim; 
  };
 
} // namespace libviennashe
 
#endif /* LIBVIENNASHE_QUANTITY_WRAPPERS_HPP */