expansion_order.hpp

Go to the documentation of this file.

#ifndef VIENNASHE_SHE_POSTPROC_EXPANSION_ORDER_HPP
#define VIENNASHE_SHE_POSTPROC_EXPANSION_ORDER_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
=============================================================================== */
 
 
 
#include <math.h>
#include <fstream>
#include <iostream>
 
#include "viennagrid/mesh/mesh.hpp"
 
#include "viennashe/forwards.h"
#include "viennashe/physics/constants.hpp"
#include "viennashe/she/postproc/macroscopic.hpp"
 
namespace viennashe
{
  namespace she
  {
 
    template <typename DeviceType, typename SHEQuantity>
    class average_expansion_order_wrapper
    {
      public:
 
        typedef double value_type;
 
        average_expansion_order_wrapper(SHEQuantity const & quan,
                                        double energy_start,
                                        double energy_end) : quan_(quan),
                                                             energy_start_(energy_start),
                                                             energy_end_(energy_end) {}
 
        template <typename CellType>
        value_type operator()(CellType const & cell) const
        {
          double sum_order = 0;   //summation of all expansion orders
          long num_energies = 0;  //no of energy points considered
 
          for (std::size_t index_H=1; index_H<quan_.get_value_H_size() - 1; ++index_H)
          {
            double kinetic_energy = quan_.get_kinetic_energy(cell, index_H);
 
            if (kinetic_energy >= energy_start_ && kinetic_energy <= energy_end_)
            {
              sum_order += quan_.get_expansion_order(cell, index_H);
              ++num_energies;
            }
          }
 
          return sum_order / num_energies;
        }
 
      private:
        SHEQuantity quan_;
        double energy_start_;
        double energy_end_;
    };
 
    template <typename DeviceType,
              typename SHEQuantity,
              typename ContainerType>
    void write_average_expansion_order_to_container(DeviceType const & device,
                                                    SHEQuantity const & quan,
                                                    ContainerType & container,
                                                    double energy_start = 0.0,
                                                    double energy_end = 1.0)
    {
      average_expansion_order_wrapper<DeviceType, SHEQuantity> wrapper(quan, energy_start, energy_end);
 
      viennashe::write_macroscopic_quantity_to_container(device, wrapper, container);
    }
 
  } //namespace she
} //namespace viennashe
 
#endif