df_runtime.h

//
// df_runtime.h
//
// Copyright (C) 2009 Edward Valeev
//
// Author: Edward Valeev <evaleev@vt.edu>
// Maintainer: EV
//
// This file is part of the SC Toolkit.
//
// The SC Toolkit is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// The SC Toolkit is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public License
// along with the SC Toolkit; see the file COPYING.LIB.  If not, write to
// the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
//
// The U.S. Government is granted a limited license as per AL 91-7.
//
 
#ifndef _mpqc_src_lib_chemistry_qc_df_df_runtime_h
#define _mpqc_src_lib_chemistry_qc_df_df_runtime_h
 
#include <chemistry/qc/lcao/df.h>
#include <chemistry/qc/lcao/tbint_runtime.h>
#include <Eigen/Dense>
#include <util/misc/sharedptr.h>
 
 
namespace sc {
 
  class ParsedDensityFittingKey {
    public:
      ParsedDensityFittingKey(const std::string& key);
 
      const std::string& key() const { return key_; }
      const std::string& space1() const { return space1_; }
      const std::string& space2() const { return space2_; }
      const std::string& fspace() const { return fspace_; }
      const std::string& kernel() const { return kernel_pkey_.key(); }
      const std::string& kernel_oper() const { return kernel_pkey_.oper(); }
      const std::string& kernel_param() const { return kernel_pkey_.params(); }
      bool ri() const { return ri_; }
 
      static std::string key(const std::string& space1,
                             const std::string& space2,
                             const std::string& fspace,
                             const std::string& kernel,
                             bool ri = false);
 
    private:
      std::string key_;
      std::string space1_, space2_, fspace_;
      ParsedTwoBodyOperSetKey kernel_pkey_;
      bool ri_;
  };
 
  class DensityFittingParams;
 
  class DensityFittingRuntime : virtual public SavableState {
    public:
      typedef DensityFittingRuntime this_type;
      typedef DistArray4 Result;
      typedef Ref<Result> ResultRef;
      typedef ParsedDensityFittingKey ParsedResultKey;
      typedef DensityFitting::MOIntsRuntime MOIntsRuntime;
#ifdef MPQC_NEW_FEATURES
      typedef Eigen::VectorXd CoefResult;
      typedef std::shared_ptr<Eigen::VectorXd> CoefResultRef;
      typedef std::pair<int, int> IntPair;
      typedef std::pair<std::string, IntPair> CoefKey;
#endif // MPQC_NEW_FEATURES
 
      // uses MOIntsRuntime to evaluate integrals
      DensityFittingRuntime(const Ref<MOIntsRuntime>& moints_runtime,
                            const DensityFittingParams* dfparams);
      DensityFittingRuntime(StateIn& si);
      void save_data_state(StateOut& so);
 
      void obsolete();
 
      const DensityFittingParams* dfparams() const { return dfparams_; }
 
      bool exists(const std::string& key) const;
 
#ifdef MPQC_NEW_FEATURES
      bool exists(const CoefKey& key) const;
#endif // MPQC_NEW_FEATURES
 
      ResultRef get(const std::string& key);   // non-const: can compute something
 
#ifdef MPQC_NEW_FEATURES
      const CoefResultRef get(const CoefKey& key);
      const CoefResultRef get(const std::string& dfkey, int bf1, int bf2){ return get(CoefKey(dfkey, IntPair(bf1, bf2))); }
#endif // MPQC_NEW_FEATURES
 
      const Ref<MOIntsRuntime>& moints_runtime() const { return moints_runtime_; }
 
      void remove_if(const std::string& space_key);
 
      static std::string default_dfbs_name(const std::string& obs_name,
                                           int incX = 0,
                                           bool force_aug = false);
 
    private:
      Ref<MOIntsRuntime> moints_runtime_;
      const DensityFittingParams* dfparams_;
 
      typedef Registry<std::string, ResultRef, detail::NonsingletonCreationPolicy > ResultRegistry;
      Ref<ResultRegistry> results_;
 
#ifdef MPQC_NEW_FEATURES
      typedef Registry<CoefKey, CoefResultRef, detail::NonsingletonCreationPolicy > CoefRegistry;
      Ref<CoefRegistry> coef_results_;
 
      CoefResultRef get_coefficients(const CoefKey& key);
 
      typedef Eigen::HouseholderQR<Eigen::MatrixXd> Decomposition;
      typedef std::map<IntPair, std::shared_ptr<Decomposition> > DecompositionMap;
      DecompositionMap decomps_;
#endif // MPQC_NEW_FEATURES
 
      // creates the result for a given key
      const ResultRef& create_result(const std::string& key);
 
      static ClassDesc class_desc_;
 
  };
 
  class DensityFittingParams : virtual public SavableState {
    public:
      DensityFittingParams(const Ref<GaussianBasisSet>& basis,
                           const std::string& kernel = std::string(),
                           const std::string& solver = std::string("cholesky_inv"));
      DensityFittingParams(StateIn&);
      ~DensityFittingParams();
      void save_data_state(StateOut&);
 
      const Ref<GaussianBasisSet>& basis() const { return basis_; }
      const std::string& kernel_key() const { return kernel_; }
      DensityFitting::SolveMethod solver() const { return solver_; }
      bool local_coulomb() const { return local_coulomb_; }
      void local_coulomb(bool val) { local_coulomb_ = val; }
      bool local_exchange() const { return local_exchange_; }
      void local_exchange(bool val) { local_exchange_ = val; }
      bool exact_diag_J() const { return exact_diag_J_; }
      void exact_diag_J(bool val) { exact_diag_J_ = val; }
      bool exact_diag_K() const { return exact_diag_K_; }
      void exact_diag_K(bool val) { exact_diag_K_ = val; }
      TwoBodyOper::type kernel_otype() const;
      std::string intparams_key() const;
 
      void print(std::ostream& o) const;
    private:
      static ClassDesc class_desc_;
 
      bool local_coulomb_;
      bool local_exchange_;
      bool exact_diag_J_;
      bool exact_diag_K_;
      Ref<GaussianBasisSet> basis_;
      std::string kernel_;
      DensityFitting::SolveMethod solver_;
  };
 
   inline bool operator==(const DensityFittingParams& A, const DensityFittingParams& B) {
    return A.basis()->equiv(B.basis()) && A.kernel_key() == B.kernel_key() && A.solver() == B.solver();
  }
 
  struct DensityFittingInfo : virtual public SavableState {
    public:
      typedef DensityFittingInfo this_type;
 
      DensityFittingInfo(const Ref<DensityFittingParams>& p,
                         const Ref<DensityFittingRuntime>& r) :
                           params_(p), runtime_(r) {}
      DensityFittingInfo(StateIn& si) {
        params_ << SavableState::restore_state(si);
        runtime_ << SavableState::restore_state(si);
      }
      void save_data_state(StateOut& so) {
        SavableState::save_state(params_.pointer(),so);
        SavableState::save_state(runtime_.pointer(),so);
      }
 
      const Ref<DensityFittingParams>& params() const { return params_; }
      const Ref<DensityFittingRuntime>& runtime() const { return runtime_; }
 
      void obsolete();
 
    private:
      Ref<DensityFittingParams> params_;
      Ref<DensityFittingRuntime> runtime_;
 
      static ClassDesc class_desc_;
  };
 
  inline bool operator==(const DensityFittingInfo& A, const DensityFittingInfo& B) {
    // dfinfo objects are equivalent if they use equivalent params and same runtime object
    return (*A.params() == *B.params()) && A.runtime() == B.runtime();
  }
 
 
} // end of namespace sc
 
#endif // end of header guard
 
 
// Local Variables:
// mode: c++
// c-file-style: "CLJ-CONDENSED"
// End: