cleanup

src/wasm/result.hpp

@@ -19,6 +19,10 @@ class Results {
         virtual ~Results() {};
         virtual postUpdateFunction_t<dtype> getPostUpdateFunction(std::shared_ptr<Model> model) = 0;
         virtual bool postUpdateFunction(std::shared_ptr<Model> model, const MPS<dtype>& psi) = 0;
+        virtual void finalize(std::shared_ptr<Model> model, const MPS<dtype>& psi) = 0;
+        /// Norm of the MPS
+        dtype finalNorm = 0;
+        std::vector<dtype> finalStates;
 };
 
 
@@ -27,6 +31,7 @@ class TfiResults : public Results<TfiModel> {
         using Model_t = TfiModel;
         TfiResults(ems::val callback, double convergence) : callback(callback), convergence(convergence), previousE(std::numeric_limits<double>::max()) {
             sigmaZ.setValues({{1, 0}, {0, -1}});
+            // sigmaZ.setValues({{0, 1}, {1, 0}});
         };
         /// @todo write a second postUpdateFunction without the JS callback and return that one if callback is null
         postUpdateFunction_t<dtype> getPostUpdateFunction(std::shared_ptr<TfiModel> model) override {
@@ -44,6 +49,10 @@ class TfiResults : public Results<TfiModel> {
             previousE = Eval;
             return false;
         }
+        void finalize(std::shared_ptr<TfiModel> model, const MPS<dtype>& psi) override {
+            this->finalNorm = psi.collapse(0);
+            this->finalStates = psi.getSiteExpectationValues(this->sigmaZ);
+        }
     private:
         e::TensorFixedSize<dtype, e::Sizes<2, 2>> sigmaZ;
         ems::val callback;
@@ -74,6 +83,11 @@ class BoseHubbardResults : public Results<BhModel> {
             previousE = Eval;
             return false;
         }
+        void finalize(std::shared_ptr<BhModel> model, const MPS<dtype>& psi) override {
+            e::TensorMap<const e::Tensor<dtype, 2>> particleNumberOperator(model->getLadderOperators().getN().data(), model->localDim, model->localDim);
+            this->finalNorm = psi.collapse(0);
+            this->finalStates = psi.getSiteExpectationValues(particleNumberOperator);
+        }
     private:
         ems::val callback;
         double convergence;

src/wasm/run.cpp

@@ -48,8 +48,14 @@ int testPerformance() {
 EMSCRIPTEN_BINDINGS(run) {
     // see https://emscripten.org/docs/porting/connecting_cpp_and_javascript/embind.html#advanced-class-concepts
     // RESULTS
-    ems::class_<Results<TfiModel>>("ResultsBaseTfi");
+    ems::class_<Results<TfiModel>>("ResultsBaseTfi")
-    ems::class_<Results<BhModel>>("ResultsBaseBh");
+        .property("finalNorm", &Results<TfiModel>::finalNorm)
+        .property("finalStates", &Results<TfiModel>::finalStates, ems::return_value_policy::reference())
+    ;
+    ems::class_<Results<BhModel>>("ResultsBaseBh")
+        .property("finalNorm", &Results<BhModel>::finalNorm)
+        .property("finalStates", &Results<BhModel>::finalStates, ems::return_value_policy::reference())
+    ;
     ems::class_<TfiResults, ems::base<Results<TfiModel>>>("ResultsTfi")
         .constructor<ems::val, double>()
     ;
@@ -76,20 +82,13 @@ EMSCRIPTEN_BINDINGS(run) {
     ems::function("initMpsSpinUp", &initMPS_spinUp<dtype>);
     ems::function("initMpsSpinRight", &initMPS_spinRight<dtype>);
     ems::function("initMpsNParticles", &initMPS_nParticles<dtype>);
-    // ems::function("initMPS_spinUp", &initMPS_spinUp);
-    ems::register_vector<double>("stdVectorDouble");
-    ems::register_vector<std::vector<double>>("stdVectorDouble2D");
-    // ems::class_<Results>("TEBDResults")
-    //     .property("M", &Results::M)
-    //     .property("E", &Results::E)
-    //     .property("S", &Results::S)
-    // ;
     // TEBD
     ems::enum_<TEBD_TYPE>("TEBD_TYPE")
         .value("BRICKWALL", TEBD_TYPE::BRICKWALL)
         .value("SECOND_ORDER", TEBD_TYPE::SECOND_ORDER)
         ;
     ems::function("runTebdTfi", &runTEBD<TfiModel>);
+    ems::function("runTebdEvolveTfi", &runTEBD_evolve<TfiModel, unsigned, Range<double>, Range<double>>);
     ems::function("runTebdPhaseDiagramTfi", &runTEBD_phaseDiagram<TfiModel, unsigned, Range<double>, Range<double>>);
     ems::function("runTebdBh", &runTEBD<BhModel>);
     ems::function("runTebdPhaseDiagramBh", &runTEBD_phaseDiagram<BhModel, unsigned, double, Range<double>, Range<double>, unsigned>);
@@ -102,6 +101,14 @@ EMSCRIPTEN_BINDINGS(run) {
     ems::function("test", &test);
     ems::function("getBuildOptions", &getBuildOptions);
     ems::function("testPerformance", &testPerformance);
+    // BASICS
+    ems::register_vector<double>("stdVectorDouble");
+    ems::register_vector<dtype>("stdVectorDType");
+    ems::register_vector<std::vector<double>>("stdVectorDouble2D");
+    ems::class_<dtype>("dtype")
+        .function("real", ems::select_overload<double()const>(&dtype::real))
+        .function("imag", ems::select_overload<double()const>(&dtype::imag))
+    ;
 };
 
 #endif

src/wasm/run.hpp

@@ -26,19 +26,6 @@
 //     std::apply([](auto&&... args){ printArgs(args...); }, results);
 // }
 
-/**
- */
-
-// EMSCRIPTEN_BINDINGS(my_class_example) {
-//   class_<MyClass>("MyClass")
-//     .constructor<int, std::string>()
-//     .function("incrementX", &MyClass::incrementX)
-//     .property("x", &MyClass::getX, &MyClass::setX)
-//     .property("x_readonly", &MyClass::getX)
-//     .class_function("getStringFromInstance", &MyClass::getStringFromInstance)
-//     ;
-// };
-
 /**
  * @brief Return a string that was set at compilation using the BUILD_OPTIONS_STRING variable
  */
@@ -49,16 +36,12 @@ enum class TEBD_TYPE {
     BRICKWALL = 0,
     SECOND_ORDER = 1,
 };
-// EMSCRIPTEN_BINDINGS(tebd_module) {
+
-//     enum_<TEBD_TYPE>(TEBD_BRICKWALL)
+inline bool post_update_sleep(const MPS<dtype>&, unsigned) {
-//         .value("TEBD_BRICKWALL", TEBD_BRICKWALL)
+    emscripten_sleep(0);
-//     ;
+    return false;
-//     class<MPS<dtype>>("MPS")
+};
-//         .constructor<unsigned>()
+static postUpdateFunction_t<dtype> post_update_sleep_F(post_update_sleep);
-//         .function("getL", &MPS<dtype>::getL)
-//         .function("getN", &MPS<dtype>::getN)
-//         .function("getN_real",
-// };
 
 // TEBD
 template<typename Model>
@@ -90,8 +73,34 @@ void runTEBD(MPS<dtype>& psi, const std::shared_ptr<Model> model, unsigned nStep
     }
     std::println("Chis: {}", psi.getChi());
     std::println("Collapse: {}", psi.collapse(0));
+    result.finalize(model, psi);
 };
 
+/// TODO everything
+template<typename Model, typename... ModelArgs>
+void runTEBD_evolve(const MPS<dtype>& psiI, unsigned nSteps, double dtReal, double dtImag, double _eps, unsigned chiMax, TEBD_TYPE type, unsigned nValues, Results<Model>& result, ModelArgs&&... args) {
+    dtype eps(_eps);
+    dtype dt(dtReal, dtImag);
+    // sanity checks
+    throwIfNaN(eps, "eps");
+    throwIfNaN(dt, "dt");
+    throwIfLessThan(nSteps, 2u, "nSteps");
+    throwIfLessThan(chiMax, 1u, "chiMax");
+    std::println("Running TEBD type={}, nSteps={}, dt={}, eps={}, chiMax={}", static_cast<int>(type), nSteps, dt, eps, chiMax);
+    MPS<dtype> psi(psiI);
+
+    for (unsigned i = 0; i < nValues; i++) {
+        std::shared_ptr<Model> model = makeModel<Model>(std::forward<ModelArgs>(args)...);
+        std::println("{:02} - Model: {}", i, *model);
+        // std::println("New psi: value at B[2](0, 1, 0)={}", psi.B(2)(0, 1, 0));
+        // printTensor(psi.B(0), "psi.B[0]");
+        // printTensor(psi.B(1), "psi.B[1]");
+        const Bonds<dtype> bonds = tebd::getTimeEvolutionMatrices(model->getH_BondsMatrices(), dt, model->localDim);
+        tebd::runBrickwall(psi, bonds, chiMax, eps, 1, post_update_sleep_F);
+        result.postUpdateFunction(model, psi);
+    }
+}
+
 
 template<typename Model, typename... ModelArgs>
 void runTEBD_phaseDiagram(const MPS<dtype>& psiI, unsigned nSteps, double dtReal, double dtImag, double _eps, unsigned chiMax, TEBD_TYPE type, unsigned nValues, Results<Model>& result, ModelArgs&&... args) {
@@ -104,17 +113,15 @@ void runTEBD_phaseDiagram(const MPS<dtype>& psiI, unsigned nSteps, double dtReal
     throwIfLessThan(chiMax, 1u, "chiMax");
     std::println("Running TEBD type={}, nSteps={}, dt={}, eps={}, chiMax={}", static_cast<int>(type), nSteps, dt, eps, chiMax);
 
-    postUpdateFunction_t<dtype> F = [](const MPS<dtype>&, unsigned) {
-        emscripten_sleep(0);
-        return false;
-    };
     for (unsigned i = 0; i < nValues; i++) {
         std::shared_ptr<Model> model = makeModel<Model>(std::forward<ModelArgs>(args)...);
         std::println("{:02} - Model: {}", i, *model);
         MPS<dtype> psi(psiI);
-        std::println("New psi: value at B[2](0, 1, 0)={}", psi.B(2)(0, 1, 0));
+        // std::println("New psi: value at B[2](0, 1, 0)={}", psi.B(2)(0, 1, 0));
+        // printTensor(psi.B(0), "psi.B[0]");
+        // printTensor(psi.B(1), "psi.B[1]");
         const Bonds<dtype> bonds = tebd::getTimeEvolutionMatrices(model->getH_BondsMatrices(), dt, model->localDim);
-        tebd::runBrickwall(psi, bonds, chiMax, eps, nSteps, F);
+        tebd::runBrickwall(psi, bonds, chiMax, eps, nSteps, post_update_sleep_F);
         result.postUpdateFunction(model, psi);
     }
 }
@@ -137,9 +144,10 @@ void runDMRG(MPS<dtype>& psi, const std::shared_ptr<Model> model, unsigned nSwee
     // initial values now
     F(psi, 0);
 
-    dmrg::run(psi, model->getH_MPO(), chiMax, eps, nSweeps, F);
+    dmrg::run(psi, model->getH_MPO(), chiMax, eps, nSweeps, F, post_update_sleep_F);
     std::println("Chis: {}", psi.getChi());
     std::println("Collapse: {}", psi.collapse(0));
+    result.finalize(model, psi);
 };
 
 
@@ -152,15 +160,12 @@ void runDMRG_phaseDiagram(const MPS<dtype>& psiI, unsigned nSweeps, double _eps,
     throwIfLessThan(chiMax, 1u, "chiMax");
     std::println("Running DMRG nSweeps={}, eps={}, chiMax={}", nSweeps, eps, chiMax);
 
-    postUpdateFunction_t<dtype> F = [](const MPS<dtype>&, unsigned) {
-        emscripten_sleep(0);
-        return false;
-    };
     for (unsigned i = 0; i < nValues; i++) {
         std::shared_ptr<Model> model = makeModel<Model>(std::forward<ModelArgs>(args)...);
         std::println("{:02} - Model: {}", i, *model);
         MPS<dtype> psi(psiI);
-        dmrg::run(psi, model->getH_MPO(), chiMax, eps, nSweeps, F);
+        dmrg::run(psi, model->getH_MPO(), chiMax, eps, nSweeps, post_update_sleep_F, post_update_sleep_F);
         result.postUpdateFunction(model, psi);
+        std::println("Collapse: {}", psi.collapse(0));
     }
 }