add_to_writer.hpp

Go to the documentation of this file.

#ifndef VIENNASHE_IO_ADD_TO_WRITER_HPP
#define VIENNASHE_IO_ADD_TO_WRITER_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
=============================================================================== */
 
// std
#include <string>
#include <vector>
 
// viennashe
#include "viennashe/forwards.h"
 
#include "viennashe/postproc/current_density.hpp"
#include "viennashe/postproc/electric_field.hpp"
#include "viennashe/she/postproc/all.hpp"
 
 
namespace viennashe
{
  namespace io
  {
    namespace detail
    {
 
      template < typename AccessorT, typename ValueT = typename AccessorT::value_type >
      class viennagrid_accessor_wrapper
      {
      public:
        typedef ValueT value_type;
 
        viennagrid_accessor_wrapper(AccessorT acc) : acc_(acc) { }
        viennagrid_accessor_wrapper(viennagrid_accessor_wrapper const & o) : acc_(o.acc_) { }
 
        template < typename ElementT >
        value_type const & at(ElementT const & el) const
        {
          static value_type cache_ = acc_(el);
          cache_ = acc_(el);
          return cache_;
        }
 
        template < typename ElementT >
        value_type const & operator()(ElementT const & el) const
        {
          static value_type cache_ = acc_(el);
          cache_ = acc_(el);
          return cache_;
        }
 
        template < typename ElementT >
        value_type const * find(ElementT const & el) const
        {
          static value_type cache_ = acc_(el);
          cache_ = acc_(el);
          return &cache_;
        }
 
        private:
          AccessorT acc_; // COPY !!!
      };
 
      template <typename MacroscopicQuantityAccessor, typename WriterType>
      void add_macroscopic_quantity_to_writer_impl(MacroscopicQuantityAccessor const & quantity,
                                              WriterType & writer,
                                              std::string name,
                                              double * dummy = 0)
      {
        (void)dummy;
        // quantity IS GOING TO BE COPIED!
        viennagrid_accessor_wrapper<MacroscopicQuantityAccessor, double> wrap(quantity);
 
        writer.add_scalar_data_on_cells(wrap, name);
      }
 
      template <typename MacroscopicQuantityAccessor, typename WriterType>
      void add_macroscopic_quantity_to_writer_impl(MacroscopicQuantityAccessor const & quantity,
                                              WriterType & writer,
                                              std::string name,
                                              std::vector<double> * dummy = 0)
      {
        (void)dummy;
        // quantity IS GOING TO BE COPIED!
        viennagrid_accessor_wrapper<MacroscopicQuantityAccessor, std::vector<double> > wrap(quantity);
        writer.add_vector_data_on_cells(wrap, name);
      }
    } // namespace detail
 
    template <typename MacroscopicQuantityAccessor, typename WriterType>
    void add_macroscopic_quantity_to_writer(MacroscopicQuantityAccessor const & quantity,
                                            WriterType & writer, std::string name)
    {
      typename MacroscopicQuantityAccessor::value_type * dummy = 0;
       // quantity IS GOING TO BE COPIED!
      viennashe::io::detail::add_macroscopic_quantity_to_writer_impl(quantity, writer, name, dummy);
    }
 
    template <typename PotentialAccessor,
              typename WriterType>
    void add_potential_to_writer(PotentialAccessor const & pot,
                                 WriterType & writer, std::string name)
    {
       // quantity IS GOING TO BE COPIED!
      viennashe::io::add_macroscopic_quantity_to_writer(pot, writer, name);
    }
 
    /*
    template <typename DeviceType,
              typename SHEQuantity,
              typename WriterType>
    void add_carrier_velocity_to_writer(DeviceType  const & device,
                                        SHEQuantity const & quan,
                                        viennashe::config::dispersion_relation_type const & dispersion,
                                        WriterType & writer,
                                        std::string name)
    {
      // get accessor
      viennashe::she::carrier_velocity_wrapper<DeviceType, SHEQuantity> velocity_wrapper(device, quan, dispersion);
      // write
      // quantity IS GOING TO BE COPIED!
      viennashe::io::add_macroscopic_quantity_to_writer(velocity_wrapper, writer, name);
    } */
 
    template <typename DeviceType,
              typename SHEQuantity,
              typename WriterType>
    void add_current_density_to_writer(DeviceType const & device,
                                       viennashe::config const & conf,
                                       SHEQuantity const & quan,
                                       WriterType & writer,
                                       std::string name)
    {
      viennashe::she::current_density_wrapper<DeviceType, SHEQuantity> current_wrapper(device, conf, quan);
      // quantity IS GOING TO BE COPIED!
      viennashe::io::add_macroscopic_quantity_to_writer(current_wrapper, writer, name);
    }
 
    template <typename DeviceType,
              typename PotentialQuantityType,
              typename CarrierQuantityType,
              typename MobilityModel,
              typename WriterType>
    void add_current_density_to_writer(DeviceType const & device,
                                       PotentialQuantityType const & potential,
                                       CarrierQuantityType   const & carrier,
                                       viennashe::carrier_type_id ctype,
                                       MobilityModel const & mobility_model,
                                       WriterType & writer,
                                       std::string name)
    {
      typedef typename viennashe::current_density_wrapper<DeviceType, PotentialQuantityType,
                                                          CarrierQuantityType, MobilityModel>  current_density_type;
      current_density_type Jfield(device, ctype, potential, carrier, mobility_model);
      // quantity IS GOING TO BE COPIED!
      viennashe::io::add_macroscopic_quantity_to_writer(Jfield, writer, name);
    }
 
    template <typename SHEQuantity,
              typename WriterType>
    void add_kinetic_carrier_energy_to_writer(viennashe::config const & conf,
                                              SHEQuantity const & quan,
                                              WriterType & writer,
                                              std::string name)
    {
      viennashe::she::carrier_energy_wrapper<SHEQuantity> wrapper(conf, quan);
      // quantity IS GOING TO BE COPIED!
      viennashe::io::add_macroscopic_quantity_to_writer(wrapper, writer, name);
    }
 
 
  } // namespace io
} // namespace viennashe
 
 
#endif  /* VIENNASHE_IO_ADD_TO_WRITER_HPP */