CompressedPropertyAccess.hpp

Go to the documentation of this file.

/*
  Copyright 2014 SINTEF ICT, Applied Mathematics.
  Copyright 2014 Statoil ASA.

  This file is part of the Open Porous Media Project (OPM).

  OPM is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  OPM is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef OPM_COMPRESSEDPROPERTYACCESS_HPP_HEADER
#define OPM_COMPRESSEDPROPERTYACCESS_HPP_HEADER

#include <opm/parser/eclipse/EclipseState/Grid/GridProperty.hpp>

#include <cassert>
#include <cstddef>
#include <memory>
#include <string>
#include <vector>

namespace Opm {
    namespace GridPropertyAccess {
        namespace Details {
            namespace EclPropImpl {
                template <typename T>
                struct HasProperty;

                template <typename T>
                struct GetProperty;

                template <>
                struct HasProperty<int> {
                    template <class PropertyContainer>
                    static bool
                    p(PropertyContainer& ecl,
                      const std::string& kw);
                };

                template <class PropertyContainer>
                bool
                HasProperty<int>::p(PropertyContainer& ecl,
                                    const std::string& kw)
                {
                    return ecl->hasIntGridProperty(kw);
                }

                template <>
                struct HasProperty<double> {
                    template <class PropertyContainer>
                    static bool
                    p(PropertyContainer& ecl,
                      const std::string& kw);
                };

                template <class PropertyContainer>
                bool
                HasProperty<double>::p(PropertyContainer& ecl,
                                       const std::string& kw)
                {
                    return ecl->hasDoubleGridProperty(kw);
                }

                template <>
                struct GetProperty<int> {
                    template <class PropertyContainer>
                    static std::shared_ptr< GridProperty<int> >
                    value(PropertyContainer& ecl,
                          const std::string& kw);
                };

                template <class PropertyContainer>
                std::shared_ptr< GridProperty<int> >
                GetProperty<int>::value(PropertyContainer& ecl,
                                        const std::string& kw)
                {
                    assert (HasProperty<int>::p(ecl, kw));

                    return ecl->getIntGridProperty(kw);
                }

                template <>
                struct GetProperty<double> {
                    template <class PropertyContainer>
                    static std::shared_ptr< GridProperty<double> >
                    value(PropertyContainer& ecl,
                          const std::string& kw);
                };

                template <class PropertyContainer>
                std::shared_ptr< GridProperty<double> >
                GetProperty<double>::value(PropertyContainer& ecl,
                                           const std::string& kw)
                {
                    assert (HasProperty<double>::p(ecl, kw));

                    return ecl->getDoubleGridProperty(kw);
                }
            } // namespace EclPropImpl

            template <typename T>
            struct EclipsePropertyArray {
                template <class PropertyContainer>
                static std::shared_ptr< GridProperty<T> >
                value(PropertyContainer& ecl,
                      const std::string& kw);
            };

            template <typename T>
            template <class PropertyContainer>
            std::shared_ptr< GridProperty<T> >
            EclipsePropertyArray<T>::value(PropertyContainer& ecl,
                                           const std::string& kw)
            {
                std::shared_ptr< GridProperty<T> > x;

                if (EclPropImpl::HasProperty<T>::p(ecl, kw)) {
                    x = EclPropImpl::GetProperty<T>::value(ecl, kw);
                }

                return x;
            }
        } // namespace Details

        namespace ArrayPolicy {
            template <typename T>
            class ExtractFromDeck {
            public:
                template <class PropertyContainer>
                ExtractFromDeck(PropertyContainer& ecl,
                                const std::string& kw,
                                const T            dflt)
                    : x_   (Details::EclipsePropertyArray<T>::value(ecl, kw))
                    , dflt_(dflt)
                {}

                typedef T value_type;

                typedef std::size_t size_type;

                value_type
                operator[](const size_type i) const
                {
                    if (x_) {
                        return x_->iget(i);
                    }
                    else {
                        return dflt_;
                    }
                }

            private:
                std::shared_ptr< GridProperty<T> > x_;

                T dflt_;
            };

            template <typename T>
            class Constant {
            public:
                Constant(const T c)
                    : c_(c)
                {}

                typedef T value_type;

                typedef std::size_t size_type;

                value_type
                operator[](const size_type i) const
                {
                    static_cast<void>(i); // Suppress "unused parameter"

                    return c_;
                }

            private:
                T c_;
            };
        } // namespace ArrayPolicy

        namespace Tag {
            struct Any {};

            struct NTG : public Any {};
        } // namespace Tag

        template <class DataArray, class PropertyTag = Tag::Any>
        class Compressed {
        public:
            Compressed(const DataArray& x,
                       const int*       gc)
                : x_ (x)
                , gc_(gc)
            {}

            typedef typename DataArray::value_type value_type;

            value_type
            operator[](const int c) const
            {
                return x_[ (gc_ == 0) ? c : gc_[c] ];
            }

        private:
            DataArray x_;

            const int* gc_;
        };
    } // namespace GridPropertyAccess
} // namespace Opm

#endif  /* OPM_COMPRESSEDPROPERTYACCESS_HPP_HEADER */