This file is indexed.

/usr/include/dune/pdelab/function/selectcomponent.hh is in libdune-pdelab-dev 2.5.0~20170124g7cf9f47a-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=8 sw=2 sts=2:
#ifndef DUNE_PDELAB_FUNCTION_SELECTCOMPONENT_HH
#define DUNE_PDELAB_FUNCTION_SELECTCOMPONENT_HH

#include <algorithm>
#include <cstddef>
#include <vector>

#include <dune/common/exceptions.hh>

#include <dune/pdelab/common/function.hh>

namespace Dune {
  namespace PDELab {

    //! Select certain component(s) of a gridfunction
    /**
     * \tparam GF   Type for the GridFunction
     * \tparam dimR Number of components of the resulting GridFunction
     *
     * \sa SelectComponentAdaptor, BoundaryGridFunctionSelectComponentAdaptor.
     */
    template<typename GF, std::size_t dimR = 1>
    class SelectComponentGridFunctionAdapter
      : public GridFunctionBase<
          GridFunctionTraits<
            typename GF::Traits::GridViewType,
            typename GF::Traits::RangeFieldType, dimR,
            FieldVector<typename GF::Traits::RangeFieldType, dimR>
            >,
          SelectComponentGridFunctionAdapter<GF, dimR>
        >
    {
    public:
      typedef GridFunctionTraits<
        typename GF::Traits::GridViewType,
        typename GF::Traits::RangeFieldType, dimR,
        FieldVector<typename GF::Traits::RangeFieldType, dimR>
        > Traits;

    private:
      typedef GridFunctionBase<
        Traits, SelectComponentGridFunctionAdapter
        > Base;

      GF& gf;
      std::size_t remap[dimR];

      void checkRemap() const {
        for(std::size_t c = 0; c < dimR; ++c)
          if(remap[c] >= GF::Traits::dimRange)
            DUNE_THROW(InvalidStateException, "remap[" << c << "] = "
                       << remap[c] << " >= GF::Traits::dimRange = "
                       << GF::Traits::dimRange);
      }
    public:
      //! construct with a consecutive range of indices
      SelectComponentGridFunctionAdapter(GF& gf_, std::size_t first) :
        gf(gf_)
      {
        for(std::size_t c = 0; c < dimR; ++c)
          remap[c] = first+c;
        checkRemap();
      }

      //! construct with a full index map
      SelectComponentGridFunctionAdapter
      ( GF& gf_, const std::vector<std::size_t> remap_) :
        gf(gf_)
      {
        if(remap_.size() != dimR)
          DUNE_THROW(Exception, "Got an index map of size "
                     << remap_.size() << " but size " << dimR << " was "
                     "expected.");
        std::copy(remap_.begin(), remap_.end(), remap);
        checkRemap();
      }

      void evaluate(const typename Traits::ElementType &e,
                    const typename Traits::DomainType &x,
                    typename Traits::RangeType &y) const
      {
        typename GF::Traits::RangeType y_;
        gf.evaluate(e,x,y_);
        for(std::size_t c = 0; c < dimR; ++c)
          y[c] = y_[remap[c]];
      }

      const typename Traits::GridViewType& getGridView() const
      { return gf.getGridView(); }

      template<typename Time>
      void setTime(Time time) { gf.setTime(time); }
    };

  } // namspace PDELab
} // namspace Dune

#endif // DUNE_PDELAB_FUNCTION_SELECTCOMPONENT_HH