Trying to generalize the number of orbital spaces.

Author: shiozaki

configure.ac

@@ -8,7 +8,7 @@ AC_CONFIG_SRCDIR([src/main.cc])
 AC_CONFIG_HEADER([config.h])
 
 # Checks for programs.
-CXXFLAGS="$CXXFLAGS -std=c++0x -O3"
+CXXFLAGS="$CXXFLAGS -std=c++0x"
 AC_PROG_CXX
 AC_PROG_CC
 AC_PROG_RANLIB

src/binarycontraction.cc

@@ -1,7 +1,8 @@
 //
-// Author:: Toru Shiozaki
-// Date  :: Feb 2009
+// Author : Toru Shiozaki
+// Date   : Feb 2009
 //
+
 #include <src/binarycontraction.h>
 #include <src/smartindex.h>
 #include <iostream>
@@ -25,8 +26,8 @@ BinaryContraction::~BinaryContraction(){
 
 
 pair<PCost, PCost>  BinaryContraction::cost_evaluater(const vector<shared_ptr<Tensor> >& tensors) {
-  PCost pcop(0,0,0);
-  PCost pcmem(0,0,0);
+  PCost pcop;
+  PCost pcmem;
 
   if (one())  
     return make_pair(pcop, pcmem);

src/cost.cc

@@ -10,15 +10,11 @@
 using namespace std;
 
 
-void PCost::add(int i, int j, int k) {
-  get<0>(pcost_) += i;
-  get<1>(pcost_) += j;
-  get<2>(pcost_) += k;
-}
-
-
 const string PCost::show() const {
-  stringstream out; out << "h" << get<0>(pcost()) << "p" << get<1>(pcost()) << "P" << get<2>(pcost());
+  stringstream out;
+  auto j = pcost_.begin();
+  for (auto i = indmap_.begin(); i != indmap_.end(); ++i, ++j)
+    out << i->first <<  *j; 
   return out.str();
 }
 

src/cost.h

@@ -11,39 +11,50 @@
 #include <algorithm>
 #include <functional>
 #include <tuple>
-
+#include <cassert>
 #include <iostream>
+#include <src/index.h>
 
-// may be substituted by the actual numbers...
-#define NUM_COMP_PARTICLE 888
-#define NUM_PARTICLE 232
-#define NUM_HOLE 28
+class PCost {
 
+  protected:
+    // a vector of integers with length cat
+    std::vector<int> pcost_;
+    // mapping information. Maybe this is not the most beautiful way..
+    Index_map indmap_;
 
-class PCost {
-  
-  protected: 
-    std::tuple<int,int,int> pcost_;// hole, particle, complete particle 
- 
   public:
-    PCost(const std::tuple<int,int,int>& pcst): pcost_(pcst) { };
-    PCost(int i, int j, int k): pcost_(std::make_tuple(i,j,k)) {};
-    PCost() { };
+    PCost(const std::vector<int>& pcst): pcost_(pcst) { };
+    PCost() { pcost_.resize(indmap_.size()); };
     ~PCost() { };
 
-    bool operator<(const PCost& other) const { return pcost_total() < other.pcost_total(); };
-    bool operator>(const PCost& other) const  { return pcost_total() > other.pcost_total(); };
+    bool operator<(const PCost& other)  const { return pcost_total() < other.pcost_total(); };
+    bool operator>(const PCost& other)  const { return pcost_total() > other.pcost_total(); };
     bool operator==(const PCost& other) const { return pcost() == other.pcost(); };
     bool operator!=(const PCost& other) const { return !(*this == other);};
 
-    const double pcost_total() const { return
-       ::log(static_cast<double>(NUM_HOLE         ))*std::get<0>(pcost_) 
-     + ::log(static_cast<double>(NUM_PARTICLE     ))*std::get<1>(pcost_)
-     + ::log(static_cast<double>(NUM_COMP_PARTICLE))*std::get<2>(pcost_);
+    const double pcost_total() const {
+      double out = 0.0;
+      auto j = indmap_.begin();
+      for (auto i = pcost_.begin(); i != pcost_.end(); ++i, ++j)
+        out += ::log(static_cast<double>(j->second.second))* *i;
+      return out;
     }
-    const std::tuple<int,int,int> pcost() const { return pcost_;};
+    const std::vector<int> pcost() const { return pcost_;};
+
+    void add(std::vector<int>& o) {
+      for (auto i = pcost_.begin(), j = o.begin(); i != pcost_.end(); ++i, ++j) *i += *j; 
+    };
+#if 0
+    void add(int i, int j, int k) {
+      assert(ORB_CLASS == 3);
+      pcost_[0] += i;
+      pcost_[1] += j;
+      pcost_[2] += k;
+    };
+#endif
 
-    void add(int, int, int); 
+    int pcost(const int i) const { return pcost_[i]; };
 
     const std::string show() const;
 
@@ -52,8 +63,8 @@ class PCost {
 
 class Cost {
 
-  protected: 
-    std::vector<PCost> cost_; 
+  protected:
+    std::vector<PCost> cost_;
 
   public:
     Cost(const std::vector<PCost>& cst) : cost_(cst) { };
@@ -65,33 +76,20 @@ class Cost {
       std::vector<PCost> myc = cost();
       for (auto i = myc.begin(), j = otherc.begin(); i != myc.end(); ++i, ++j) {
         if (j == otherc.end()) return false;
-        if      (*i < *j)      return true; 
+        if      (*i < *j)      return true;
         else if (*i > *j)      return false;
       }
-      return true; 
+      return true;
     };
 
-#define use_old_code_cost 0
-#if use_old_code_cost
-    bool operator==(const Cost& other) const { 
-      std::vector<PCost> otherc = other.cost();
-      std::vector<PCost> myc = cost();
-      if (myc.size() != otherc.size()) return false;
-      for (auto i = myc.begin(), j = otherc.begin(); i != myc.end(); ++i, ++j) {
-        if (*i != *j ) return false;
-      }
-      return true;
-    }
-#else
     bool operator==(const Cost& other) const { return cost()==other.cost(); };
-#endif
     bool operator!=(const Cost& other) const { return !(*this == other);};
     bool operator>(const Cost& other)  const { return !(*this < other);};
 
     const std::vector<PCost> cost() const {return cost_;};
 
     void add_pcost(const PCost& p) { cost_.push_back(p); };
-    void add_pcost(int i, int j, int k) { PCost a(i, j, k); cost_.push_back(a); };
+//  void add_pcost(int i, int j, int k) { PCost a(i, j, k); cost_.push_back(a); };
 
     const std::string show() const;
 

src/index.cc

@@ -44,7 +44,7 @@ Index::~Index() {
 const string Index::show() const {
 
   ostringstream buffer;
-  buffer << type() << num() << (dagger() ? "+" : "");
+  buffer << type_str() << num() << (dagger() ? "+" : "");
 
   return buffer.str();
 }

src/index.h

@@ -2,21 +2,52 @@
 // Author : Toru Shiozaki
 // Date   : Feb 2009
 //
+
 #ifndef _smith_index_h
 #define _smith_index_h
 
 #include <string>
 #include <iostream>
 #include <vector>
 #include <memory>
+#include <list>
+#include <stdexcept>
+
+// This defines the index classes. If you want to generalize this generator
+// to more general cases (RASPT2, for instance), then just add some entry.
+// Indices will be sorted using these numbers when tensors are canonicalized.
+class Index_map {
+  protected:
+    std::list<std::pair<std::string, std::pair<int,int> > > map_;
+  public:
+    Index_map() { 
+      map_.push_back(std::make_pair("h", std::make_pair(0, 28)));
+      map_.push_back(std::make_pair("a", std::make_pair(1, 6)));
+      map_.push_back(std::make_pair("p", std::make_pair(2, 232)));
+      map_.push_back(std::make_pair("P", std::make_pair(3, 888)));
+    };
+    ~Index_map() {};
+    int num_orb_class() const { return map_.size(); };
+    int size() const { return num_orb_class(); };
+
+    const int type(const std::string& type_) const {
+      auto iter = map_.begin();
+      for (; iter != map_.end(); ++iter) if (iter->first == type_) break;
+      if (iter == map_.end()) throw std::runtime_error("key is no valid in Index::type()"); 
+      return iter->second.first;
+    };
+    std::list<std::pair<std::string, std::pair<int,int> > >::const_iterator begin() const { return map_.begin(); };
+    std::list<std::pair<std::string, std::pair<int,int> > >::const_iterator end() const { return map_.end(); };
+};
 
 class Index {
 
   protected:
     // basic info for deriving equations.
     bool dagger_;
     std::string type_;
-    std::shared_ptr<int> num_; 
+    std::shared_ptr<int> num_;
+    Index_map indmap_;
 
   public:
     Index(const std::string);
@@ -25,11 +56,14 @@ class Index {
     // returns dagger_
     bool dagger() const { return dagger_; };
     // reutrns type_
-    const std::string type() const { return type_; };
+    const std::string type_str() const { return type_; };
+    const int type() const { indmap_.type(type_); };
     // returns num_
     int num() const { return *num_; };
     // pointer to num_, which is used for updating num_ in Wick's theorem
     std::shared_ptr<int> num_pointer() { return num_; };
+    // returns indmap_
+    Index_map indmap() const { return indmap_; };
 
     // show function
     const std::string show() const;