LinearMethod Class Reference

Inheritance diagram for LinearMethod:

Collaboration diagram for LinearMethod:

Public Member Functions
Real	getLowestEigenvector (Matrix< Real > &A, std::vector< Real > &ev) const
Real	getNonLinearRescale (std::vector< Real > &dP, Matrix< Real > &S, const QMCCostFunctionBase &optTarget) const

Static Public Member Functions
static Real	selectEigenvalue (std::vector< Real > &eigenvals, Matrix< Real > &eigenvectors, Real zerozero, std::vector< Real > &ev)
	Select eigenvalue and return corresponding scaled eigenvector. More...
static Real	getLowestEigenvector_Inv (Matrix< Real > &A, Matrix< Real > &B, std::vector< Real > &ev)
	Solve the generalized eigenvalue problem and return a scaled eigenvector corresponding to the selected eigenvalue. More...
static Real	getLowestEigenvector_Gen (Matrix< Real > &A, Matrix< Real > &B, std::vector< Real > &ev)
	Solve the generalized eigenvalue problem and return a scaled eigenvector corresponding to the selected eigenvalue. More...

Private Types
using	Real = QMCTraits::RealType

Private Member Functions
void	getNonLinearRange (int &first, int &last, const QMCCostFunctionBase &optTarget) const

Detailed Description

Definition at line 31 of file LinearMethod.h.

Member Typedef Documentation

Real

using Real = QMCTraits::RealType

private

Definition at line 33 of file LinearMethod.h.

Member Function Documentation

getLowestEigenvector()

LinearMethod::Real getLowestEigenvector	(	Matrix< Real > &	A,
		std::vector< Real > &	ev
	)		const

Definition at line 123 of file LinearMethod.cpp.

References qmcplusplus::Units::distance::A, APP_ABORT, qmcplusplus::app_log(), Matrix< T, Alloc >::data(), LAPACK::geev(), and qmcplusplus::Units::second.

Referenced by QMCFixedSampleLinearOptimizeBatched::previous_linear_methods_run(), QMCFixedSampleLinearOptimize::run(), and QMCFixedSampleLinearOptimizeBatched::solveShiftsWithoutLMYEngine().

{
  int Nl(ev.size());
  //   Getting the optimal worksize
  Real zerozero = A(0, 0);
  char jl('N');
  char jr('V');
  std::vector<Real> alphar(Nl), alphai(Nl), beta(Nl);
  Matrix<Real> eigenT(Nl, Nl);
  Matrix<Real> eigenD(Nl, Nl);
  int info;
  int lwork(-1);
  std::vector<Real> work(1);
  LAPACK::geev(&jl, &jr, &Nl, A.data(), &Nl, &alphar[0], &alphai[0], eigenD.data(), &Nl, eigenT.data(), &Nl, &work[0],
               &lwork, &info);
  lwork = int(work[0]);
  work.resize(lwork);

  LAPACK::geev(&jl, &jr, &Nl, A.data(), &Nl, &alphar[0], &alphai[0], eigenD.data(), &Nl, eigenT.data(), &Nl, &work[0],
               &lwork, &info);
  if (info != 0)
  {
    APP_ABORT("Invalid Matrix Diagonalization Function!");
  }

  // Filter and sort to find desired eigenvalue.
  // Filter accepts eigenvalues between E_0 and E_0 - 100.0,
  // where E_0 is H(0,0), the current estimate for the VMC energy.
  // Sort searches for eigenvalue closest to E_0 - 2.0

  bool found_any_eigenvalue = false;
  std::vector<std::pair<Real, int>> mappedEigenvalues(Nl);
  for (int i = 0; i < Nl; i++)
  {
    Real evi(alphar[i]);
    if ((evi < zerozero) && (evi > (zerozero - 1e2)))
    {
      mappedEigenvalues[i].first  = (evi - zerozero + 2.0) * (evi - zerozero + 2.0);
      mappedEigenvalues[i].second = i;
      found_any_eigenvalue        = true;
    }
    else
    {
      mappedEigenvalues[i].first  = std::numeric_limits<Real>::max();
      mappedEigenvalues[i].second = i;
    }
  }

  // Sometimes there is no eigenvalue less than E_0, but there is one slightly higher.
  // Run filter and sort again, except this time accept eigenvalues between E_0 + 100.0 and E_0 - 100.0.
  // Since it's already been determined there are no eigenvalues below E_0, the sort
  // finds the eigenvalue closest to E_0.
  if (!found_any_eigenvalue)
  {
    app_log() << "No eigenvalues passed initial filter. Trying broader 100 a.u. filter" << std::endl;

    bool found_higher_eigenvalue;
    for (int i = 0; i < Nl; i++)
    {
      Real evi(alphar[i]);
      if ((evi < zerozero + 1e2) && (evi > (zerozero - 1e2)))
      {
        mappedEigenvalues[i].first  = (evi - zerozero + 2.0) * (evi - zerozero + 2.0);
        mappedEigenvalues[i].second = i;
        found_higher_eigenvalue     = true;
      }
      else
      {
        mappedEigenvalues[i].first  = std::numeric_limits<Real>::max();
        mappedEigenvalues[i].second = i;
      }
    }
    if (!found_higher_eigenvalue)
    {
      app_log() << "No eigenvalues passed second filter. Optimization is likely to fail." << std::endl;
    }
  }
  std::sort(mappedEigenvalues.begin(), mappedEigenvalues.end());
  //         for (int i=0; i<4; i++) app_log()<<i<<": "<<alphar[mappedEigenvalues[i].second]<< std::endl;
  for (int i = 0; i < Nl; i++)
    ev[i] = eigenT(mappedEigenvalues[0].second, i) / eigenT(mappedEigenvalues[0].second, 0);
  return alphar[mappedEigenvalues[0].second];
  //     }
}

getLowestEigenvector_Gen()

LinearMethod::Real getLowestEigenvector_Gen ( Matrix< Real > &  A, Matrix< Real > &  B, std::vector< Real > &  ev  )

static

Solve the generalized eigenvalue problem and return a scaled eigenvector corresponding to the selected eigenvalue.

Parameters

[in]	A	Hamiltonian matrix
[in]	B	Overlap matrix
[out]	ev	Scaled eigenvector

This uses a generalized eigenvalue solver (LAPACK ggev).

Definition at line 41 of file LinearMethod.cpp.

References qmcplusplus::Units::distance::A, B(), LinearMethod::selectEigenvalue(), and Eigensolver::solveGeneralizedEigenvalues().

Referenced by QMCFixedSampleLinearOptimizeBatched::one_shift_run().

{
  int Nl(ev.size());
  std::vector<Real> alphar(Nl);
  Matrix<Real> eigenT(Nl, Nl);
  Real zerozero = A(0, 0);
  Eigensolver::solveGeneralizedEigenvalues(A, B, alphar, eigenT);
  return selectEigenvalue(alphar, eigenT, zerozero, ev);
}

getLowestEigenvector_Inv()

LinearMethod::Real getLowestEigenvector_Inv ( Matrix< Real > &  A, Matrix< Real > &  B, std::vector< Real > &  ev  )

static

Solve the generalized eigenvalue problem and return a scaled eigenvector corresponding to the selected eigenvalue.

Parameters

[in]	A	Hamiltonian matrix
[in]	B	Overlap matrix
[out]	ev	Scaled eigenvector

This uses a regular eigenvalue solver for B^-1 A (LAPACK geev). In theory using the generalized eigenvalue solver is more numerically stable, but in practice this solver is sufficiently stable, and is faster than the generalized solver.

Definition at line 31 of file LinearMethod.cpp.

References qmcplusplus::Units::distance::A, B(), LinearMethod::selectEigenvalue(), and Eigensolver::solveGeneralizedEigenvalues_Inv().

Referenced by QMCFixedSampleLinearOptimizeBatched::one_shift_run().

{
  int Nl(ev.size());
  std::vector<Real> alphar(Nl);
  Matrix<Real> eigenT(Nl, Nl);
  Real zerozero = A(0, 0);
  Eigensolver::solveGeneralizedEigenvalues_Inv(A, B, alphar, eigenT);
  return selectEigenvalue(alphar, eigenT, zerozero, ev);
}

getNonLinearRange()

void getNonLinearRange ( int &  first, int &  last, const QMCCostFunctionBase &  optTarget  ) const

private

Definition at line 208 of file LinearMethod.cpp.

References QMCCostFunctionBase::getParameterTypes(), and optimize::LINEAR_P.

Referenced by LinearMethod::getNonLinearRescale().

{
  std::vector<int> types;
  optTarget.getParameterTypes(types);
  first = 0;
  last  = types.size();
  //assume all non-linear coeffs are together.
  if (types[0] == optimize::LINEAR_P)
  {
    int i(0);
    while (i < types.size())
    {
      if (types[i] == optimize::LINEAR_P)
        first = i;
      i++;
    }
    first++;
  }
  else
  {
    int i(types.size() - 1);
    while (i >= 0)
    {
      if (types[i] == optimize::LINEAR_P)
        last = i;
      i--;
    }
  }
  //     returns the number of non-linear parameters.
  //    app_log()<<"line params: "<<first<<" "<<last<< std::endl;
}

getNonLinearRescale()

LinearMethod::Real getNonLinearRescale	(	std::vector< Real > &	dP,
		Matrix< Real > &	S,
		const QMCCostFunctionBase &	optTarget
	)		const

Definition at line 240 of file LinearMethod.cpp.

References LinearMethod::getNonLinearRange(), and qmcplusplus::sqrt().

Referenced by QMCFixedSampleLinearOptimizeBatched::one_shift_run(), QMCFixedSampleLinearOptimizeBatched::previous_linear_methods_run(), QMCFixedSampleLinearOptimize::run(), and QMCFixedSampleLinearOptimizeBatched::solveShiftsWithoutLMYEngine().

{
  int first(0), last(0);
  getNonLinearRange(first, last, optTarget);
  if (first == last)
    return 1.0;
  Real rescale(1.0);
  Real xi(0.5);
  Real D(0.0);
  for (int i = first; i < last; i++)
    for (int j = first; j < last; j++)
      D += S(i + 1, j + 1) * dP[i + 1] * dP[j + 1];
  rescale = (1 - xi) * D / ((1 - xi) + xi * std::sqrt(1 + D));
  rescale = 1.0 / (1.0 - rescale);
  //     app_log()<<"rescale: "<<rescale<< std::endl;
  return rescale;
}

selectEigenvalue()

LinearMethod::Real selectEigenvalue ( std::vector< Real > &  eigenvals, Matrix< Real > &  eigenvectors, Real  zerozero, std::vector< Real > &  ev  )

static

Select eigenvalue and return corresponding scaled eigenvector.

Parameters

[in]	eigenvals	Eigenvalues
[in]	eigenvectors	Eigenvectors
[in]	zerozero	The H(0,0) element, used to guide eigenvalue selection
[out]	ev	The eigenvector scaled by the reciprocal of the first element

Returns

The selected eigenvalue

Definition at line 57 of file LinearMethod.cpp.

References qmcplusplus::app_log(), and qmcplusplus::Units::second.

Referenced by LinearMethod::getLowestEigenvector_Gen(), LinearMethod::getLowestEigenvector_Inv(), and qmcplusplus::TEST_CASE().

{
  // Filter and sort to find desired eigenvalue.
  // Filter accepts eigenvalues between E_0 and E_0 - 100.0,
  // where E_0 is H(0,0), the current estimate for the VMC energy.
  // Sort searches for eigenvalue closest to E_0 - 2.0
  int Nl = eigenvals.size();

  bool found_any_eigenvalue = false;
  std::vector<std::pair<Real, int>> mappedEigenvalues(Nl);
  for (int i = 0; i < Nl; i++)
  {
    Real evi(eigenvals[i]);
    if ((evi < zerozero) && (evi > (zerozero - 1e2)))
    {
      mappedEigenvalues[i].first  = (evi - zerozero + 2.0) * (evi - zerozero + 2.0);
      mappedEigenvalues[i].second = i;
      found_any_eigenvalue        = true;
    }
    else
    {
      mappedEigenvalues[i].first  = std::numeric_limits<Real>::max();
      mappedEigenvalues[i].second = i;
    }
  }

  // Sometimes there is no eigenvalue less than E_0, but there is one slightly higher.
  // Run filter and sort again, except this time accept eigenvalues between E_0 + 100.0 and E_0 - 100.0.
  // Since it's already been determined there are no eigenvalues below E_0, the sort
  // finds the eigenvalue closest to E_0.
  if (!found_any_eigenvalue)
  {
    app_log() << "No eigenvalues passed initial filter. Trying broader 100 a.u. filter" << std::endl;

    bool found_higher_eigenvalue;
    for (int i = 0; i < Nl; i++)
    {
      Real evi(eigenvals[i]);
      if ((evi < zerozero + 1e2) && (evi > (zerozero - 1e2)))
      {
        mappedEigenvalues[i].first  = (evi - zerozero + 2.0) * (evi - zerozero + 2.0);
        mappedEigenvalues[i].second = i;
        found_higher_eigenvalue     = true;
      }
      else
      {
        mappedEigenvalues[i].first  = std::numeric_limits<Real>::max();
        mappedEigenvalues[i].second = i;
      }
    }
    if (!found_higher_eigenvalue)
    {
      app_log() << "No eigenvalues passed second filter. Optimization is likely to fail." << std::endl;
    }
  }
  std::sort(mappedEigenvalues.begin(), mappedEigenvalues.end());
  //         for (int i=0; i<4; i++) app_log()<<i<<": "<<alphar[mappedEigenvalues[i].second]<< std::endl;
  for (int i = 0; i < Nl; i++)
    ev[i] = eigenvectors(mappedEigenvalues[0].second, i) / eigenvectors(mappedEigenvalues[0].second, 0);
  return eigenvals[mappedEigenvalues[0].second];
}

---

The documentation for this class was generated from the following files:

• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCDrivers/WFOpt/LinearMethod.h
• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCDrivers/WFOpt/LinearMethod.cpp