Intrepid2_DerivedBasis_HDIV_QUAD.hpp

// @HEADER
// *****************************************************************************
//                           Intrepid2 Package
//
// Copyright 2007 NTESS and the Intrepid2 contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER

#ifndef Intrepid2_DerivedBasis_HIV_QUAD_h
#define Intrepid2_DerivedBasis_HIV_QUAD_h

#include <Kokkos_DynRankView.hpp>

#include "Intrepid2_Polynomials.hpp"
#include "Intrepid2_Sacado.hpp"

#include "Intrepid2_DirectSumBasis.hpp"
#include "Intrepid2_TensorBasis.hpp"

namespace Intrepid2
{
  template<class HGRAD_LINE, class HVOL_LINE>
  class Basis_Derived_HDIV_Family1_QUAD
  : public Basis_TensorBasis<typename HGRAD_LINE::BasisBase>
  {
  public:
    using ExecutionSpace  = typename HGRAD_LINE::ExecutionSpace;
    using OutputValueType = typename HGRAD_LINE::OutputValueType;
    using PointValueType  = typename HGRAD_LINE::PointValueType;
    
    using OutputViewType = typename HGRAD_LINE::OutputViewType;
    using PointViewType  = typename HGRAD_LINE::PointViewType ;
    using ScalarViewType = typename HGRAD_LINE::ScalarViewType;
    
    using LineGradBasis = HGRAD_LINE;
    using LineHVolBasis = HVOL_LINE;
    
    using BasisBase = typename HGRAD_LINE::BasisBase;
    
    using TensorBasis = Basis_TensorBasis<BasisBase>;
  public:
    Basis_Derived_HDIV_Family1_QUAD(int polyOrder_x, int polyOrder_y, const EPointType pointType)
    :
    TensorBasis(Teuchos::rcp(new LineHVolBasis(polyOrder_x-1,pointType)),
                Teuchos::rcp(new LineGradBasis(polyOrder_y,pointType)))
    {
      this->functionSpace_ = FUNCTION_SPACE_HDIV;
      this->setShardsTopologyAndTags();
    }
    
    virtual OperatorTensorDecomposition getSimpleOperatorDecomposition(const EOperator &operatorType) const override
    {
      const EOperator VALUE = Intrepid2::OPERATOR_VALUE;
      const EOperator GRAD  = Intrepid2::OPERATOR_GRAD;
      const EOperator DIV   = Intrepid2::OPERATOR_DIV;
      
      // ESEAS implements H(div) as rotated H(curl), which involves weighting family1 with -1.
      // We follow that here to simplify verification tests that involve ESEAS.
      const double weight = -1.0;
      if (operatorType == VALUE)
      {
        std::vector< std::vector<EOperator> > ops(2);
        ops[0] = std::vector<EOperator>{};
        ops[1] = std::vector<EOperator>{VALUE,VALUE};
        std::vector<double> weights {0.0,weight};
        return OperatorTensorDecomposition(ops, weights);
      }
      else if (operatorType == DIV)
      {
        // family 1 is nonzero in the y component, so the div is (VALUE,GRAD)
        std::vector< std::vector<EOperator> > ops(1); // scalar value
        ops[0] = std::vector<EOperator>{VALUE,GRAD};
        std::vector<double> weights {weight};
        return OperatorTensorDecomposition(ops,weights);
      }
      else
      {
        INTREPID2_TEST_FOR_EXCEPTION(true, std::invalid_argument, "Unsupported operator type");
      }
    }
    
    using TensorBasis::getValues;
    
    virtual void getValues(OutputViewType outputValues, const EOperator operatorType,
                           const PointViewType  inputPoints1, const PointViewType inputPoints2,
                           bool tensorPoints) const override
    {
      // ESEAS implements H(div) as rotated H(curl), which involves weighting family1 with -1.
      // We follow that here to simplify verification tests that involve ESEAS.
      const double weight = -1.0;
      
      Intrepid2::EOperator op1, op2;
      if (operatorType == Intrepid2::OPERATOR_VALUE)
      {
        op1 = Intrepid2::OPERATOR_VALUE;
        op2 = Intrepid2::OPERATOR_VALUE;
        
        // family 1 goes in the y component; 0 in the x component
        auto outputValuesComponent1 = Kokkos::subview(outputValues,Kokkos::ALL(),Kokkos::ALL(),0);
        auto outputValuesComponent2 = Kokkos::subview(outputValues,Kokkos::ALL(),Kokkos::ALL(),1);
        
        this->TensorBasis::getValues(outputValuesComponent2,
                                     inputPoints1, op1,
                                     inputPoints2, op2, tensorPoints, weight);
        // place 0 in the y component
        Kokkos::deep_copy(outputValuesComponent1,0.0);
      }
      else if (operatorType == Intrepid2::OPERATOR_DIV)
      {
        // family 1 gets a d/dy applied to the second (nonzero) vector component
        // since this is H(VOL)(x) * H(GRAD)(y), this amounts to taking the derivative in the second tensorial component
        op1 = Intrepid2::OPERATOR_VALUE;
        op2 = Intrepid2::OPERATOR_GRAD;
        
        this->TensorBasis::getValues(outputValues,
                                     inputPoints1, op1,
                                     inputPoints2, op2, tensorPoints, weight);
      }
      else
      {
        INTREPID2_TEST_FOR_EXCEPTION(true,std::invalid_argument,"operator not yet supported");
      }
    }

    virtual void getDofCoeffs( ScalarViewType dofCoeffs ) const override {
      auto dofCoeffs1 = Kokkos::subview(dofCoeffs,Kokkos::ALL(),0);
      auto dofCoeffs2 = Kokkos::subview(dofCoeffs,Kokkos::ALL(),1);
      Kokkos::deep_copy(dofCoeffs1,0.0);
      this->TensorBasis::getDofCoeffs(dofCoeffs2);
      //multiply by weight = -1.0
      Kokkos::parallel_for( Kokkos::RangePolicy<ExecutionSpace>(0, dofCoeffs2.extent(0)),
          KOKKOS_LAMBDA (const int i){ dofCoeffs2(i) *= -1.0; });
    }

  };

  template<class HGRAD_LINE, class HVOL_LINE>
  class Basis_Derived_HDIV_Family2_QUAD
  : public Basis_TensorBasis<typename HGRAD_LINE::BasisBase>
  {
    using ExecutionSpace  = typename HGRAD_LINE::ExecutionSpace;
    using OutputValueType = typename HGRAD_LINE::OutputValueType;
    using PointValueType  = typename HGRAD_LINE::PointValueType;
    
    using OutputViewType = typename HGRAD_LINE::OutputViewType;
    using PointViewType  = typename HGRAD_LINE::PointViewType ;
    using ScalarViewType = typename HGRAD_LINE::ScalarViewType;
    
    using LineGradBasis = HGRAD_LINE;
    using LineHVolBasis = HVOL_LINE;
    
    using BasisBase = typename HGRAD_LINE::BasisBase;
    
    using TensorBasis = Basis_TensorBasis<BasisBase>;
  public:
    Basis_Derived_HDIV_Family2_QUAD(int polyOrder_x, int polyOrder_y, const EPointType pointType = POINTTYPE_DEFAULT)
    :
    TensorBasis(Teuchos::rcp(new LineGradBasis(polyOrder_x,pointType)),
                Teuchos::rcp(new LineHVolBasis(polyOrder_y-1,pointType)))
    {
      this->functionSpace_ = FUNCTION_SPACE_HDIV;
      this->setShardsTopologyAndTags();
    }
    
       virtual OperatorTensorDecomposition getSimpleOperatorDecomposition(const EOperator &operatorType) const override
       {
         const EOperator VALUE = Intrepid2::OPERATOR_VALUE;
         const EOperator GRAD  = Intrepid2::OPERATOR_GRAD;
         const EOperator DIV   = Intrepid2::OPERATOR_DIV;
         
         const double weight = 1.0; // family 2 (x component nonzero)
         if (operatorType == VALUE)
         {
           std::vector< std::vector<EOperator> > ops(2);
           ops[0] = std::vector<EOperator>{VALUE,VALUE};
           ops[1] = std::vector<EOperator>{};
           std::vector<double> weights {weight, 0.0};
           return OperatorTensorDecomposition(ops, weights);
         }
         else if (operatorType == DIV)
         {
           // family 2 is nonzero in the x component, so the div is (GRAD,VALUE)
           std::vector< std::vector<EOperator> > ops(1); // scalar value
           ops[0] = std::vector<EOperator>{GRAD,VALUE};
           std::vector<double> weights {weight};
           return OperatorTensorDecomposition(ops,weights);
         }
         else
         {
           INTREPID2_TEST_FOR_EXCEPTION(true, std::invalid_argument, "Unsupported operator type");
         }
       }
    
    using TensorBasis::getValues;
    
    virtual void getValues(OutputViewType outputValues, const EOperator operatorType,
                           const PointViewType  inputPoints1, const PointViewType inputPoints2,
                           bool tensorPoints) const override
    {
      Intrepid2::EOperator op1, op2;
      if (operatorType == Intrepid2::OPERATOR_VALUE)
      {
        op1 = Intrepid2::OPERATOR_VALUE;
        op2 = Intrepid2::OPERATOR_VALUE;
        
        // family 2 goes in the x component; 0 in the x component
        auto outputValuesComponent1 = Kokkos::subview(outputValues,Kokkos::ALL(),Kokkos::ALL(),0);
        auto outputValuesComponent2 = Kokkos::subview(outputValues,Kokkos::ALL(),Kokkos::ALL(),1);
        
        this->TensorBasis::getValues(outputValuesComponent1,
                                     inputPoints1, op1,
                                     inputPoints2, op2, tensorPoints);
        // place 0 in the y component
        Kokkos::deep_copy(outputValuesComponent2, 0.0);
      }
      else if (operatorType == Intrepid2::OPERATOR_DIV)
      {
        // family 2 gets a d/dx applied to the first (nonzero) vector component
        // since this is H(GRAD)(x) * H(VOL)(y), this amounts to taking the derivative in the first tensorial component
        op1 = Intrepid2::OPERATOR_GRAD;
        op2 = Intrepid2::OPERATOR_VALUE;
        
        this->TensorBasis::getValues(outputValues,
                                     inputPoints1, op1,
                                     inputPoints2, op2, tensorPoints);
      }
      else
      {
        INTREPID2_TEST_FOR_EXCEPTION(true,std::invalid_argument,"operator not yet supported");
      }
    }

    virtual void getDofCoeffs( ScalarViewType dofCoeffs ) const override {
      auto dofCoeffs1 = Kokkos::subview(dofCoeffs,Kokkos::ALL(),0);
      auto dofCoeffs2 = Kokkos::subview(dofCoeffs,Kokkos::ALL(),1);
      this->TensorBasis::getDofCoeffs(dofCoeffs1);
      Kokkos::deep_copy(dofCoeffs2,0.0);
    }

  };
  
  template<class HGRAD_LINE, class HVOL_LINE>
  class Basis_Derived_HDIV_QUAD
  : public Basis_DirectSumBasis <typename HGRAD_LINE::BasisBase>
  {
    using Family1 = Basis_Derived_HDIV_Family1_QUAD<HGRAD_LINE, HVOL_LINE>;
    using Family2 = Basis_Derived_HDIV_Family2_QUAD<HGRAD_LINE, HVOL_LINE>;
    using DirectSumBasis = Basis_DirectSumBasis <typename HGRAD_LINE::BasisBase>;

  public:
    using ExecutionSpace  = typename HGRAD_LINE::ExecutionSpace;
    using OutputValueType = typename HGRAD_LINE::OutputValueType;
    using PointValueType  = typename HGRAD_LINE::PointValueType;
    
    using BasisBase = typename HGRAD_LINE::BasisBase;

  protected:
    std::string name_;
    ordinal_type order_x_;
    ordinal_type order_y_;
    EPointType pointType_;
  public:
    Basis_Derived_HDIV_QUAD(int polyOrder_x, int polyOrder_y, const EPointType pointType=POINTTYPE_DEFAULT)
    :
    DirectSumBasis(Teuchos::rcp(new Family1(polyOrder_x, polyOrder_y, pointType)),
                   Teuchos::rcp(new Family2(polyOrder_x, polyOrder_y, pointType)))
    {
      this->functionSpace_ = FUNCTION_SPACE_HDIV;

      std::ostringstream basisName;
      basisName << "HDIV_QUAD (" << this->DirectSumBasis::getName() << ")";
      name_ = basisName.str();

      order_x_ = polyOrder_x;
      order_y_ = polyOrder_y;
      pointType_ = pointType;
    }
    
    Basis_Derived_HDIV_QUAD(int polyOrder, const EPointType pointType=POINTTYPE_DEFAULT) : Basis_Derived_HDIV_QUAD(polyOrder, polyOrder, pointType) {}

    virtual bool requireOrientation() const override {
      return true;
    }

    virtual
    const char*
    getName() const override {
      return name_.c_str();
    }

    Teuchos::RCP<BasisBase>
      getSubCellRefBasis(const ordinal_type subCellDim, const ordinal_type subCellOrd) const override{
      if(subCellDim == 1) {
        switch(subCellOrd) {
        case 0:
        case 2:
          return Teuchos::rcp( new HVOL_LINE(order_x_-1, pointType_) );
        case 1:
        case 3:
          return Teuchos::rcp( new HVOL_LINE(order_y_-1, pointType_) );
        }
      }

      INTREPID2_TEST_FOR_EXCEPTION(true,std::invalid_argument,"Input parameters out of bounds");
    }
    
    virtual HostBasisPtr<OutputValueType, PointValueType>
    getHostBasis() const override {
      using HostBasis  = Basis_Derived_HDIV_QUAD<typename HGRAD_LINE::HostBasis, typename HVOL_LINE::HostBasis>;
      
      auto hostBasis = Teuchos::rcp(new HostBasis(order_x_, order_y_, pointType_));
      
      return hostBasis;
    }
  };
} // end namespace Intrepid2

#endif /* Intrepid2_DerivedBasis_HIV_QUAD_h */