MixingScheme.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright (c) 2021.                                                        *
 * The Regents of the University of Michigan and DFT-EFE developers.          *
 *                                                                            *
 * This file is part of the DFT-EFE code.                                     *
 *                                                                            *
 * DFT-EFE is free software: you can redistribute it and/or modify            *
 *   it under the terms of the Lesser GNU General Public License as           *
 *   published by the Free Software Foundation, either version 3 of           *
 *   the License, or (at your option) any later version.                      *
 *                                                                            *
 * DFT-EFE is distributed in the hope that it will be useful, but             *
 *   WITHOUT ANY WARRANTY; without even the implied warranty                  *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                     *
 *   See the Lesser GNU General Public License for more details.              *
 *                                                                            *
 * You should have received a copy of the GNU Lesser General Public           *
 *   License at the top level of DFT-EFE distribution.  If not, see           *
 *   <https://www.gnu.org/licenses/>.                                         *
 ******************************************************************************/
 
/*
 * @author Avirup Sircar
 * @adapted from
 * "https://github.com/dftfeDevelopers/dftfe/blob/publicGithubDevelop/include/MixingScheme.h"
 */
 
#ifndef dftefeMixingScheme_h
#define dftefeMixingScheme_h
 
#include <deque>
#include <utils/MemorySpaceType.h>
#include <linearAlgebra/MultiVector.h>
#include <linearAlgebra/BlasLapack.h>
#include <utils/ConditionalOStream.h>
 
namespace dftefe
{
  namespace ksdft
  {
    enum class mixingVariable
    {
      rho,
      gradRho, // GGA — dependent (empty weights)
      /*magZ,      // spin-polarized / non-collinear
      gradMagZ,  // spin-polarized GGA / non-collinear GGA — dependent
      magY,      // non-collinear only
      gradMagY,  // non-collinear GGA — dependent
      magX,      // non-collinear only
      gradMagX,  // non-collinear GGA — dependent
      tau,       // meta-GGA — primary, full JxW weights
      tauMagZ,   // MGGA spin-polarized
      tauMagY,   // MGGA non-collinear
      tauMagX,   // MGGA non-collinear*/
    };
 
    template <typename ValueTypeMixingVariable, typename ValueTypeWeights>
    class MixingScheme
    {
    public:
      using ValueType =
        linearAlgebra::blasLapack::scalar_type<ValueTypeWeights,
                                               ValueTypeMixingVariable>;
 
    public:
      MixingScheme(const utils::mpi::MPIComm &mpiComm);
 
      ~MixingScheme() = default;
 
      size_type
      lengthOfHistory();
 
      void
      computeAndersonMixingCoeff(
        const std::vector<mixingVariable> mixingVariablesList,
        linearAlgebra::LinAlgOpContext<utils::MemorySpace::HOST>
          &linAlgOpContextHost);
 
      void
      computeAdaptiveAndersonMixingParameter();
 
      void
      popOldHistory(size_type mixingHistory);
 
      void
      clearHistory();
 
      void
      addMixingVariable(
        const mixingVariable mixingVariableList,
        const utils::MemoryStorage<ValueTypeWeights, utils::MemorySpace::HOST>
          &          weightDotProducts,
        const bool   performMPIReduce,
        const double mixingValue,
        const bool   isAdaptiveMixing);
 
      template <utils::MemorySpace memorySpace>
      void
      addVariableToInHist(const mixingVariable           mixingVariableName,
                          const ValueTypeMixingVariable *inputVariableToInHist,
                          const size_type                length);
 
      template <utils::MemorySpace memorySpace>
      void
      addVariableToResidualHist(
        const mixingVariable           mixingVariableName,
        const ValueTypeMixingVariable *inputVariableToResidualHist,
        const size_type                length);
 
      template <utils::MemorySpace memorySpace>
      void
      mixVariable(const mixingVariable     mixingVariableName,
                  ValueTypeMixingVariable *outputVariable,
                  const size_type          lenVar);
 
      bool
      hasVariable(mixingVariable var) const;
 
    private:
      void
      computeMixingMatrices(
        const std::deque<std::vector<ValueTypeMixingVariable>> &inHist,
        const std::deque<std::vector<ValueTypeMixingVariable>> &outHist,
        const utils::MemoryStorage<ValueTypeWeights, utils::MemorySpace::HOST>
          &                     weightDotProducts,
        const bool              isPerformMixing,
        const bool              isMPIAllReduce,
        std::vector<ValueType> &A,
        std::vector<ValueType> &c);
 
      std::vector<ValueType> d_A, d_c;
      ValueType              d_cFinal;
 
      std::map<mixingVariable, std::deque<std::vector<ValueTypeMixingVariable>>>
        d_variableHistoryIn, d_variableHistoryResidual;
      std::map<mixingVariable,
               utils::MemoryStorage<ValueTypeWeights, utils::MemorySpace::HOST>>
                                     d_vectorDotProductWeights;
      std::map<mixingVariable, bool> d_performMPIReduce;
 
      const MPI_Comm &d_mpiComm;
 
      std::map<mixingVariable, double> d_mixingParameter;
      std::map<mixingVariable, bool>   d_isAdaptiveMixing;
      bool                             d_anyMixingParameterAdaptive;
      bool                           d_adaptiveMixingParameterDecLastIteration;
      bool                           d_adaptiveMixingParameterDecAllIterations;
      bool                           d_adaptiveMixingParameterIncAllIterations;
      size_type                      d_mixingHistory;
      std::map<mixingVariable, bool> d_performMixing;
      utils::ConditionalOStream      d_rootCout;
    };
  } // namespace ksdft
} //  end of namespace dftefe
#include <ksdft/MixingScheme.t.cpp>
#endif // dftefeMixingScheme_h