src/lib/chemistry/qc/mbptr12/moints_runtime.h

//
// moints_runtime.h
//
// Copyright (C) 2008 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.
//

#ifdef __GNUG__
#pragma interface
#endif

#ifndef _mpqc_src_lib_chemistry_qc_mbptr12_mointsruntime_h
#define _mpqc_src_lib_chemistry_qc_mbptr12_mointsruntime_h

#include <util/state/state.h>
#include <chemistry/qc/mbptr12/r12ia.h>
#include <chemistry/qc/mbptr12/spin.h>
#include <chemistry/qc/mbptr12/transform_factory.h>

namespace sc {

  class MOIntsRuntime : virtual public SavableState {
    public:
      // for now use the typedef, later replace R12IntsAcc with TwoBodyIntsAcc
      typedef TwoBodyMOIntsTransform TwoBodyIntsTransform;
      // for now use the typedef, later replace R12IntsAcc with TwoBodyIntsAcc
      typedef R12IntsAcc TwoBodyIntsAcc;
      MOIntsRuntime(const Ref<MOIntsTransformFactory>& factory);
      MOIntsRuntime(StateIn& si);
      void save_data_state(StateOut& so);

      bool exists(const std::string& key) const;

      Ref<TwoBodyIntsTransform> get(const std::string& key);   // non-const: can add transforms

      std::string params_key(const Ref<IntParams>& params) const;
      Ref<IntParams> params(const std::string& key) const;
      // register key->params mapping
      void register_params(const std::string& key, const Ref<IntParams>& params) const;
      // register key->params mapping. A unique random key is generated automatically and returned
      std::string register_params(const Ref<IntParams>& params) const;
      std::string descr_key(const Ref<TwoBodyIntDescr>& descr);

      const Ref<MOIntsTransformFactory>& factory() const { return factory_; }

      class Layout {
        public:
          Layout(const std::string& str);
          Layout(const Layout& other);
          Layout& operator=(const Layout& other);
          bool operator==(const Layout& other) const;
          operator std::string();

        private:
          typedef enum {
            b1b2_k1k2, // physicists layout
            b1k1_b2k2  // chemists layout
          } Type;
          Type type_;
      };
      static Layout Layout_b1b2_k1k2;  // physicists layout
      static Layout Layout_b1k1_b2k2;  // chemists layout

    private:
      Ref<MOIntsTransformFactory> factory_;  // that creates transforms

      // Maps key to IntParams. IntParams objects are not unique, hence should compare them instead of pointers
      typedef Registry<std::string, Ref<IntParams>, detail::NonsingletonCreationPolicy, std::equal_to<std::string>,
                       RefObjectEqual<IntParams> > ParamRegistry;
      Ref<ParamRegistry> params_;

      // Map to TwoBodyMOIntsTransform objects that have been computed previously
      typedef Registry<std::string, Ref<TwoBodyMOIntsTransform>, detail::NonsingletonCreationPolicy > TformRegistry;
      Ref<TformRegistry> tforms_;

      // creates a transform object for a given key
      const Ref<TwoBodyMOIntsTransform>& create_tform(const std::string& key);

      Ref<TwoBodyIntDescr> create_descr(const std::string& oper_key,
                                        const std::string& params_key);

  };

  class ParsedTwoBodyIntKey {
    public:
      ParsedTwoBodyIntKey(const std::string& key);

      const std::string& key() const { return key_; }
      const std::string& bra1() const { return bra1_; }
      const std::string& bra2() const { return bra2_; }
      const std::string& ket1() const { return ket1_; }
      const std::string& ket2() const { return ket2_; }
      const std::string& oper() const { return oper_; }
      const std::string& params() const { return params_; }
      const std::string& layout() const { return layout_; }

      static std::string key(const std::string& bra1,
                             const std::string& bra2,
                             const std::string& ket1,
                             const std::string& ket2,
                             const std::string& oper,
                             const std::string& params,
                             const std::string& layout);
      static std::string key(const std::string& bra1,
                             const std::string& bra2,
                             const std::string& ket1,
                             const std::string& ket2,
                             const std::string& descr,
                             const std::string& layout);
      static std::string key(const Ref<TwoBodyIntDescr>& descr);
      static Ref<TwoBodyIntDescr> create_descr(const std::string& oper_key,
                                               const Ref<IntParams>& p,
                                               const Ref<Integral>& integral);

    private:
      std::string key_;
      std::string bra1_, bra2_, ket1_, ket2_;
      std::string oper_;
      std::string params_;
      std::string layout_;
  };

} // end of namespace sc

#endif /* end of header guard */

// Local Variables:
// mode: c++
// c-file-style: "CLJ-CONDENSED"
// End:

---