FractionalOccupancyFunction.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
 */
 
#ifndef dftefeFractionalOccupancyFunction_h
#define dftefeFractionalOccupancyFunction_h
 
#include <linearAlgebra/NewtonRaphsonSolver.h>
#include <linearAlgebra/NewtonRaphsonSolverFunction.h>
#include <linearAlgebra/BisectionSolverFunction.h>
 
namespace dftefe
{
  namespace ksdft
  {
    double
    fermiDirac(const double eigenValue,
               const double fermiEnergy,
               const double kb,
               const double T);
 
    double
    fermiDiracDer(const double eigenValue,
                  const double fermiEnergy,
                  const double kb,
                  const double T);
 
    class FractionalOccupancyFunction
      : public linearAlgebra::NewtonRaphsonSolverFunction<double>,
        public linearAlgebra::BisectionSolverFunction<double>
    {
    public:
      FractionalOccupancyFunction(const std::vector<double> &eigenValues,
                                  const size_type            numElectrons,
                                  const double               kb,
                                  const double               T,
                                  const double               initialGuess);
 
      ~FractionalOccupancyFunction() = default;
 
      const double
      getValue(double &x) const override;
 
      const double
      getForce(double &x) const override;
 
      void
      setSolution(const double &x) override;
 
      void
      getSolution(double &solution) override;
 
      const double &
      getInitialGuess() const override;
 
      const double
      getLowerBound() const override;
 
      const double
      getUpperBound() const override;
 
    private:
      // Computes d_lowerBound/d_upperBound: starts from
      // [min(d_eigenValues), max(d_eigenValues)] and, if that does not
      // already bracket a root of getValue(), expands both ends outward
      // by the bracket's own width and rechecks - repeated up to 1000
      // times before giving up (throws otherwise). This bracket
      // construction is only valid because getValue() (a sum of
      // Fermi-Dirac sigmoids) is strictly monotonic in x - a property
      // specific to this function, not something the generic
      // BisectionSolver can assume for an arbitrary BisectionSolverFunction,
      // which is why this lives here rather than there.
      void
      computeBracket();
 
      double              d_x;
      double              d_initialGuess;
      std::vector<double> d_eigenValues;
      size_type           d_numElectrons;
      double              d_kb;
      double              d_T;
      double              d_lowerBound;
      double              d_upperBound;
 
    }; // end of class FractionalOccupancyFunction
  }    // end of namespace ksdft
} // end of namespace dftefe
#endif // dftefeFractionalOccupancyFunction_h