filter.hpp

Go to the documentation of this file.

#ifndef VIENNASHE_UTIL_FILTER_HPP
#define VIENNASHE_UTIL_FILTER_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 <iostream>
#include <sstream>
#include <string>
#include <stdexcept>
 
#include "viennagrid/mesh/coboundary_iteration.hpp"
 
#include "viennashe/forwards.h"
#include "viennashe/materials/all.hpp"
#include "viennashe/util/enable_if.hpp"
 
namespace viennashe
{
  namespace util
  {
 
    struct any_filter
    {
      template <typename T>
      bool operator()(T const &) const { return true; }
    };
 
    struct none_filter
    {
      template <typename T>
      bool operator()(T const &) const { return false; }
    };
 
    template <typename DeviceType>
    class semiconductor_filter
    {
        typedef typename DeviceType::mesh_type     MeshType;
 
      public:
        typedef typename viennagrid::result_of::cell<MeshType>::type         cell_type;
 
        semiconductor_filter(DeviceType const & d) : device_(d) {}
 
        bool operator()(cell_type const & cell) const { return viennashe::materials::is_semiconductor(device_.get_material(cell)); }
 
      private:
        DeviceType const & device_;
    };
 
    template <typename DeviceType>
    class contact_filter
    {
        typedef typename DeviceType::mesh_type     MeshType;
 
      public:
        typedef typename viennagrid::result_of::vertex<MeshType>::type      vertex_type;
        typedef typename viennagrid::result_of::cell<MeshType>::type        cell_type;
 
        contact_filter(DeviceType const & d) : device_(d) {}
 
        bool operator()(vertex_type const & v) const { return device_.has_contact_potential(v); }
        bool operator()(cell_type   const & c) const { return device_.has_contact_potential(c); }
 
      private:
        DeviceType const & device_;
    };
 
    template <typename DeviceType>
    class no_contact_filter
    {
        typedef typename DeviceType::mesh_type     MeshType;
 
      public:
        typedef typename viennagrid::result_of::vertex<MeshType>::type        vertex_type;
        typedef typename viennagrid::result_of::cell<MeshType>::type          cell_type;
 
        no_contact_filter(DeviceType const & d) : device_(d) {}
 
        bool operator()(vertex_type const & v) const { return !device_.has_contact_potential(v); }
        bool operator()(cell_type const & cell) const { return !device_.has_contact_potential(cell); }
 
      private:
        DeviceType const & device_;
    };
 
 
    template <typename DeviceType>
    class no_contact_and_semiconductor_filter
    {
        typedef typename DeviceType::mesh_type     MeshType;
 
      public:
        typedef typename viennagrid::result_of::cell<MeshType>::type         cell_type;
 
        no_contact_and_semiconductor_filter(DeviceType const & d) : device_(d) {}
 
        bool operator()(cell_type const & cell) const
        {
          return !device_.has_contact_potential(cell)
               && viennashe::materials::is_semiconductor(device_.get_material(cell));
        }
 
      private:
        DeviceType const & device_;
    };
 
 
 
    namespace detail
    {
      template <long a, long b>
      struct is_lesser
      {
        enum { value = (a < b) };
      };
    } // detail
     //TODO: Think about adding this generic filter to ViennaGrid
    template <typename DeviceType, typename ElementTagT, typename CheckerType>
    class vicinity_filter
    {
        typedef typename DeviceType::mesh_type     MeshType;
 
      public:
        vicinity_filter(DeviceType const & d, CheckerType const & c) : device_(d), checker_(c) {}
 
        // checks on ncell coboundary
        template <typename NCellType>
        typename viennashe::enable_if< detail::is_lesser<NCellType::tag::dim, ElementTagT::dim>::value, //topological dimension
                                       bool>::type
        operator()(NCellType const & cell) const
        {
          typedef typename viennagrid::result_of::const_coboundary_range<MeshType, NCellType, ElementTagT>::type    VicinityContainer;
          typedef typename viennagrid::result_of::iterator<VicinityContainer>::type                             VicinityIterator;
 
          VicinityContainer vicinity(device_.mesh(), viennagrid::handle(device_.mesh(), cell));
          for (VicinityIterator vit  = vicinity.begin();
                                vit != vicinity.end();
                              ++vit)
          {
            if (checker_(*vit))
              return true;
          }
 
          return false;
        }
 
        // checks on ncell boundary
        template <typename NCellType>
        typename viennashe::enable_if< (NCellType::tag::dim > ElementTagT::dim), //topological dimension
                                        bool>::type
        operator()(NCellType const & cell) const
        {
          typedef typename viennagrid::result_of::const_element_range<NCellType, ElementTagT>::type  VicinityContainer;
          typedef typename viennagrid::result_of::iterator<VicinityContainer>::type                  VicinityIterator;
 
          VicinityContainer vicinity = viennagrid::elements<ElementTagT>(cell);
          for (VicinityIterator vit  = vicinity.begin();
                                vit != vicinity.end();
                              ++vit)
          {
            if (checker_(*vit))
              return true;
          }
 
          return false;
        }
 
      private:
        DeviceType const & device_;
        CheckerType const & checker_;
    };
 
 
    template <typename DeviceType>
    class metal_filter
    {
        typedef typename DeviceType::mesh_type     MeshType;
 
      public:
        typedef typename viennagrid::result_of::cells<MeshType>::type         cell_type;
 
        metal_filter(DeviceType const & d) : device_(d) {}
 
        bool operator()(cell_type const & cell) const { return viennashe::materials::is_conductor(device_.get_material(cell)); }
 
      private:
        DeviceType const & device_;
    };
 
    template <typename DeviceType>
    class oxide_filter
    {
        typedef typename DeviceType::mesh_type     MeshType;
 
      public:
        typedef typename viennagrid::result_of::cell<MeshType>::type         cell_type;
 
        oxide_filter(DeviceType const & d) : device_(d) {}
 
        bool operator()(cell_type const & cell) const { return viennashe::materials::is_insulator(device_.get_material(cell)); }
 
      private:
        DeviceType const & device_;
    };
 
 
 
    // feel free to add further filters here
 
 
  } //namespace util
} //namespace viennashe
#endif