MueLu_VariableDofLaplacianFactory_decl.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//        MueLu: A package for multigrid based preconditioning
//
// Copyright 2012 NTESS and the MueLu contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER

#ifndef PACKAGES_MUELU_SRC_GRAPH_MUELU_VARIABLEDOFLAPLACIANFACTORY_DECL_HPP_
#define PACKAGES_MUELU_SRC_GRAPH_MUELU_VARIABLEDOFLAPLACIANFACTORY_DECL_HPP_

#include "MueLu_ConfigDefs.hpp"
#include "MueLu_SingleLevelFactoryBase.hpp"
#include "MueLu_VariableDofLaplacianFactory_fwd.hpp"
#include "MueLu_Level_fwd.hpp"

#include "MueLu_Utilities_fwd.hpp"

namespace MueLu {

template <class Scalar        = DefaultScalar,
          class LocalOrdinal  = DefaultLocalOrdinal,
          class GlobalOrdinal = DefaultGlobalOrdinal,
          class Node          = DefaultNode>
class VariableDofLaplacianFactory : public SingleLevelFactoryBase {
#undef MUELU_VARIABLEDOFLAPLACIANFACTORY_SHORT
#include "MueLu_UseShortNames.hpp"

 public:


  VariableDofLaplacianFactory();

  virtual ~VariableDofLaplacianFactory() {}

  RCP<const ParameterList> GetValidParameterList() const;




  void DeclareInput(Level& currentLevel) const;


  void Build(Level& currentLevel) const;  // Build

 private:
  void buildPaddedMap(const Teuchos::ArrayRCP<const LocalOrdinal>& dofPresent, std::vector<LocalOrdinal>& map, size_t nDofs) const;
  void assignGhostLocalNodeIds(const Teuchos::RCP<const Map>& rowDofMap, const Teuchos::RCP<const Map>& colDofMap, std::vector<LocalOrdinal>& myLocalNodeIds, const std::vector<LocalOrdinal>& dofMap, size_t maxDofPerNode, size_t& nLocalNodes, size_t& nLocalPlusGhostNodes, Teuchos::RCP<const Teuchos::Comm<int> > comm) const;
  void squeezeOutNnzs(Teuchos::ArrayRCP<size_t>& rowPtr, Teuchos::ArrayRCP<LocalOrdinal>& cols, Teuchos::ArrayRCP<Scalar>& vals, const std::vector<bool>& keep) const;
  void buildLaplacian(const Teuchos::ArrayRCP<size_t>& rowPtr, const Teuchos::ArrayRCP<LocalOrdinal>& cols, Teuchos::ArrayRCP<Scalar>& vals, const size_t& numdim, const RCP<Xpetra::MultiVector<typename Teuchos::ScalarTraits<Scalar>::magnitudeType, LocalOrdinal, GlobalOrdinal, Node> >& ghostedCoords) const;

  template <class listType>
  void MueLu_az_sort(listType list[], size_t N, size_t list2[], Scalar list3[]) const {
    /* local variables */

    listType RR, K;
    size_t l, r, j, i;
    int flag;
    size_t RR2;
    Scalar RR3;

    /*********************** execution begins ******************************/

    if (N <= 1) return;

    l  = N / 2 + 1;
    r  = N - 1;
    l  = l - 1;
    RR = list[l - 1];
    K  = list[l - 1];

    if ((list2 != NULL) && (list3 != NULL)) {
      RR2 = list2[l - 1];
      RR3 = list3[l - 1];
      while (r != 0) {
        j    = l;
        flag = 1;

        while (flag == 1) {
          i = j;
          j = j + j;

          if (j > r + 1)
            flag = 0;
          else {
            if (j < r + 1)
              if (list[j] > list[j - 1]) j = j + 1;

            if (list[j - 1] > K) {
              list[i - 1]  = list[j - 1];
              list2[i - 1] = list2[j - 1];
              list3[i - 1] = list3[j - 1];
            } else {
              flag = 0;
            }
          }
        }

        list[i - 1]  = RR;
        list2[i - 1] = RR2;
        list3[i - 1] = RR3;

        if (l == 1) {
          RR  = list[r];
          RR2 = list2[r];
          RR3 = list3[r];

          K        = list[r];
          list[r]  = list[0];
          list2[r] = list2[0];
          list3[r] = list3[0];
          r        = r - 1;
        } else {
          l   = l - 1;
          RR  = list[l - 1];
          RR2 = list2[l - 1];
          RR3 = list3[l - 1];
          K   = list[l - 1];
        }
      }

      list[0]  = RR;
      list2[0] = RR2;
      list3[0] = RR3;
    } else if (list2 != NULL) {
      RR2 = list2[l - 1];
      while (r != 0) {
        j    = l;
        flag = 1;

        while (flag == 1) {
          i = j;
          j = j + j;

          if (j > r + 1)
            flag = 0;
          else {
            if (j < r + 1)
              if (list[j] > list[j - 1]) j = j + 1;

            if (list[j - 1] > K) {
              list[i - 1]  = list[j - 1];
              list2[i - 1] = list2[j - 1];
            } else {
              flag = 0;
            }
          }
        }

        list[i - 1]  = RR;
        list2[i - 1] = RR2;

        if (l == 1) {
          RR  = list[r];
          RR2 = list2[r];

          K        = list[r];
          list[r]  = list[0];
          list2[r] = list2[0];
          r        = r - 1;
        } else {
          l   = l - 1;
          RR  = list[l - 1];
          RR2 = list2[l - 1];
          K   = list[l - 1];
        }
      }

      list[0]  = RR;
      list2[0] = RR2;
    } else if (list3 != NULL) {
      RR3 = list3[l - 1];
      while (r != 0) {
        j    = l;
        flag = 1;

        while (flag == 1) {
          i = j;
          j = j + j;

          if (j > r + 1)
            flag = 0;
          else {
            if (j < r + 1)
              if (list[j] > list[j - 1]) j = j + 1;

            if (list[j - 1] > K) {
              list[i - 1]  = list[j - 1];
              list3[i - 1] = list3[j - 1];
            } else {
              flag = 0;
            }
          }
        }

        list[i - 1]  = RR;
        list3[i - 1] = RR3;

        if (l == 1) {
          RR  = list[r];
          RR3 = list3[r];

          K        = list[r];
          list[r]  = list[0];
          list3[r] = list3[0];
          r        = r - 1;
        } else {
          l   = l - 1;
          RR  = list[l - 1];
          RR3 = list3[l - 1];
          K   = list[l - 1];
        }
      }

      list[0]  = RR;
      list3[0] = RR3;

    } else {
      while (r != 0) {
        j    = l;
        flag = 1;

        while (flag == 1) {
          i = j;
          j = j + j;

          if (j > r + 1)
            flag = 0;
          else {
            if (j < r + 1)
              if (list[j] > list[j - 1]) j = j + 1;

            if (list[j - 1] > K) {
              list[i - 1] = list[j - 1];
            } else {
              flag = 0;
            }
          }
        }

        list[i - 1] = RR;

        if (l == 1) {
          RR = list[r];

          K       = list[r];
          list[r] = list[0];
          r       = r - 1;
        } else {
          l  = l - 1;
          RR = list[l - 1];
          K  = list[l - 1];
        }
      }

      list[0] = RR;
    }
  }

};  // class CoalesceDropFactory

}  // namespace MueLu

#define MUELU_VARIABLEDOFLAPLACIANFACTORY_SHORT

#endif /* PACKAGES_MUELU_SRC_GRAPH_MUELU_VARIABLEDOFLAPLACIANFACTORY_DECL_HPP_ */