Intrepid2_TensorArgumentIterator.hpp

Go to the documentation of this file.

// @HEADER
// ************************************************************************
//
//                           Intrepid2 Package
//                 Copyright (2007) Sandia Corporation
//
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Kyungjoo Kim  (kyukim@sandia.gov),
//                    Mauro Perego  (mperego@sandia.gov), or
//                    Nate Roberts  (nvrober@sandia.gov),
//
// ************************************************************************
// @HEADER

#ifndef Intrepid2_TensorArgumentIterator_h
#define Intrepid2_TensorArgumentIterator_h

#include "Intrepid2_TensorData.hpp"
#include "Intrepid2_Types.hpp"

namespace Intrepid2
{
  class TensorArgumentIterator {
    Kokkos::Array<ordinal_type,Parameters::MaxTensorComponents> arguments_;
    Kokkos::Array<ordinal_type,Parameters::MaxTensorComponents> bounds_;
    ordinal_type numTensorComponents_;
  public:
    template<class Scalar, typename ExecSpaceType>
    KOKKOS_INLINE_FUNCTION
    TensorArgumentIterator(const TensorData<Scalar,ExecSpaceType> &tensorData, const ordinal_type argumentOrdinal)
    :
    numTensorComponents_(tensorData.numTensorComponents())
    {
      for (ordinal_type r=0; r<numTensorComponents_; r++)
      {
        arguments_[r] = 0;
        bounds_[r]    = tensorData.getTensorComponent(r).extent_int(argumentOrdinal);
      }
    }
    
    template<class Scalar, typename ExecSpaceType>
    KOKKOS_INLINE_FUNCTION
    TensorArgumentIterator(const TensorData<Scalar,ExecSpaceType> &tensorData, const ordinal_type argumentOrdinal, const ordinal_type numTensorComponents)
    :
    numTensorComponents_(numTensorComponents)
    {
      for (ordinal_type r=0; r<numTensorComponents_; r++)
      {
        arguments_[r] = 0;
        bounds_[r]    = tensorData.getTensorComponent(r).extent_int(argumentOrdinal);
      }
    }
    
    TensorArgumentIterator(const std::vector<ordinal_type> tensorComponentBounds)
    :
    numTensorComponents_(tensorComponentBounds.size())
    {
      for (ordinal_type r=0; r<numTensorComponents_; r++)
      {
        arguments_[r] = 0;
        bounds_[r]    = tensorComponentBounds[r];
      }
    }
    
    template<size_t rank>
    KOKKOS_INLINE_FUNCTION
    TensorArgumentIterator(const Kokkos::Array<ordinal_type,rank> &tensorComponentBounds)
    :
    numTensorComponents_(rank)
    {
      for (ordinal_type r=0; r<rank; r++)
      {
        arguments_[r] = 0;
        bounds_[r]    = tensorComponentBounds[r];
      }
    }
    
    KOKKOS_INLINE_FUNCTION ordinal_type increment()
    {
      ordinal_type r = numTensorComponents_ - 1;
      while (arguments_[r] + 1 >= bounds_[r])
      {
        arguments_[r] = 0; // reset
        r--;
        if (r < 0) break;
      }
      if (r >= 0) ++arguments_[r];
      return r;
    }
    
    KOKKOS_INLINE_FUNCTION
    ordinal_type nextIncrementResult() const
    {
      ordinal_type r = numTensorComponents_ - 1;
      while (arguments_[r] + 1 >= bounds_[r])
      {
        r--;
        if (r < 0) break;
      }
      return r;
    }
    
    KOKKOS_INLINE_FUNCTION const ordinal_type & argument(const ordinal_type &r) const
    {
      return arguments_[r];
    }
    
    KOKKOS_INLINE_FUNCTION ordinal_type enumerationIndex() const
    {
      // commented-out code belongs to implementation with rightmost argument as the fastest-moving.  We may want to support this as an option.
//      ordinal_type i = 0;
//      for (ordinal_type r=0; r<numTensorComponents_-1; r++)
//      {
//        i += arguments_[r];
//        i *= bounds_[r+1];
//      }
//      i += arguments_[numTensorComponents_-1];
//      return i;
      
      // TensorData's numbering has the leftmost argument as the fastest-moving
      // We return that numbering here.
      ordinal_type i = 0;
      for (ordinal_type r=numTensorComponents_-1; r>0; r--)
      {
        i += arguments_[r];
        i *= bounds_[r-1];
      }
      i += arguments_[0];
      return i;
    }
    
    KOKKOS_INLINE_FUNCTION ordinal_type relativeEnumerationIndex(const ordinal_type &startingComponent) const
    {
      // commented-out code belongs to implementation with rightmost argument as the fastest-moving.  We may want to support this as an option.
//      ordinal_type i = 0;
//      for (ordinal_type r=startingComponent; r<numTensorComponents_-1; r++)
//      {
//        i += arguments_[r];
//        i *= bounds_[r+1];
//      }
//      i += arguments_[numTensorComponents_-1];
//      return i;
      
      // TensorData's numbering has the leftmost argument as the fastest-moving
      // We return that numbering here.
      ordinal_type i = 0;
      for (ordinal_type r=numTensorComponents_-1; r>startingComponent; r--)
      {
        i += arguments_[r];
        i *= bounds_[r-1];
      }
      i += arguments_[startingComponent];
      return i;
    }
    
    KOKKOS_INLINE_FUNCTION ordinal_type relativeEnumerationSpan(const ordinal_type &startingComponent) const
    {
      ordinal_type i = 1;
      for (ordinal_type r=startingComponent; r<numTensorComponents_; r++)
      {
        i *= bounds_[r];
      }
      return i;
    }
    
    KOKKOS_INLINE_FUNCTION
    void reset(ordinal_type from_component_number=0)
    {
      for (ordinal_type r=from_component_number; r<numTensorComponents_; r++)
      {
        arguments_[r] = 0;
      }
    }
    
    KOKKOS_INLINE_FUNCTION
    void setArgumentForComponent(const ordinal_type &r, const ordinal_type &i)
    {
      arguments_[r] = i;
    }
    
    KOKKOS_INLINE_FUNCTION
    void setEnumerationIndex(const ordinal_type &enumerationIndex)
    {
      ordinal_type remainder = enumerationIndex;
      for (ordinal_type d=0; d<numTensorComponents_; d++)
      {
        arguments_[d] = remainder % bounds_[d];
        remainder  /= bounds_[d];
      }
    }
    
    KOKKOS_INLINE_FUNCTION
    void copyArguments(TensorArgumentIterator &otherArgumentIterator, const ordinal_type &r0_from, const ordinal_type &r0_to, const ordinal_type &numArguments)
    {
      for (ordinal_type i=0; i<numArguments; i++)
      {
        arguments_[r0_to + i] = otherArgumentIterator.argument(r0_from + i);
      }
    }
    
  };
} // namespace Intrepid2

#endif /* Intrepid2_TensorArgumentIterator_h */