13_01_DMRG.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Density Matrix Renormalization Group (DMRG) method\n",
    "\n",
    "The block decimation idea\n",
    "-------------------------\n",
    "\n",
    "![In the NRG scheme, we truncate the basis by keeping the $m$\n",
    "eigenstates of the Hamiltonian with the lowest eigenvalues<span\n",
    "data-label=\"fig:nrg\"></span>](figures/fig_decimation.png \"fig:\") ![In\n",
    "the NRG scheme, we truncate the basis by keeping the $m$ eigenstates of\n",
    "the Hamiltonian with the lowest eigenvalues<span\n",
    "data-label=\"fig:nrg\"></span>](figures/fig_nrg.png \"fig:\")\n",
    "\n",
    "Let us try a simple idea, using the recursion scheme described above. At\n",
    "every step in the recursion, we add one spin on the right, and our basis\n",
    "dimension grows by a factor $2$. At some point during this recursion,\n",
    "the matrix will be too large to deal with. So let us fix a maximum\n",
    "number of states that we want to keep, $m$. At certain point during the\n",
    "process, the basis dimension will become larger than $m$. It is here\n",
    "that we start applying the truncation rule: diagonalize the Hamiltonian\n",
    "matrix exactly, and keep only the $m$ states with <span>*lowest*</span>\n",
    "eigenvalues(see Fig. \\[fig:nrg\\]).\n",
    "\n",
    "As the system grows, the basis of the left block changes as we rotate to\n",
    "the new basis of eigenstates of the Hamiltonian. This is done by using a\n",
    "unitary transformation $U$. This matrix $U$ is nothing else but the\n",
    "matrix with the eigenstates ordered in columns. Therefore, adding a spin\n",
    "to the block now involves two steps: (i) we need to build the ‘tilde’\n",
    "operators as before, and (ii) rotate the Hamiltonian matrix and the\n",
    "tilde operators to the new basis.\n",
    "\n",
    "![Adding a site to a block now involves a truncation and a change of\n",
    "basis<span data-label=\"fig:new_block\"></span>](figures/fig_add_left.png)\n",
    "\n",
    "Let us assume that our old block before adding a site has a basis\n",
    "$\\{|\\alpha_{i-1}\\rangle\\}$, of dimension $D_{i-1}$, and the site has a\n",
    "basis $\\{|s_{i}\\rangle\\}$ of dimension $d$. The new block basis\n",
    "$\\{|\\alpha_{i-1},s_{i}\\rangle\\}$ has dimension $d\\times D_{i-1}$, such\n",
    "that we can easily diagonalize it to obtain all the eigenvalues and\n",
    "corresponding eigenvectors $\\{|\\alpha_{i+1}\\rangle\\}$. We build the\n",
    "matrix $U$ as the $D_{i-1} \\times D_{i}$ unitary matrix with the\n",
    "$D_{i}=m$ eigenvectors with largest eigenvalues in the columns:\n",
    "$$U_{\\alpha_{i-1}s_i,\\alpha_i} = \\langle \\alpha_{i-1}s_i|\\alpha_i\\rangle.$$\n",
    "Before the rotation, the operators had matrix elements:\n",
    "$$\\tilde{O}_{\\alpha_{i-1}s_i,\\alpha'_{i-1}s'_i} = \\langle \\alpha_{i-1}s_i |\\hat{O}|\\alpha'_{i-1}s'_i\\rangle.$$\n",
    "We can now rotate all the tilde operators to the new basis as:\n",
    "$$\\begin{aligned}\n",
    "\\tilde{O}_{\\alpha_i,\\alpha'_i} & = & \\langle \\alpha_i |\\hat{O}|\\alpha'_i\\rangle = \\sum_{\\alpha_{i-1},s_i} \\sum_{\\alpha'_{i-1}s'_i} \\langle \\alpha_i|\\alpha_{i-1}s\\rangle\\langle \\alpha_{i-1} s_i|\\hat{O}|\\alpha'_{i-1}s'_i\\rangle\\langle \\alpha'_{i-1}s'|\\alpha_i\\rangle\n",
    "\\nonumber \\\\\n",
    "& = & \\sum_{\\alpha_{i-1},s_i} \\sum_{\\alpha'_{i-1}s'_i} (U^\\dagger)_{\\alpha_i,\\alpha_{i-1}s_i} \\tilde{O}_{\\alpha_i \\alpha'_i} U_{\\alpha'_{i-1}s'_i,\\alpha'_i}\\end{aligned}$$\n",
    "where the new matrices will have dimensions $m \\times m$. we can now use\n",
    "these matrices to continue to block-growing process by adding another\n",
    "site. This can be repeated until the energy per site converges, or until\n",
    "we reach a desired system size.\n",
    "\n",
    "It may seem that this new basis would be a natural choice is we assume\n",
    "that the physics of the problem is described by different manifolds with\n",
    "different energy scales. If we keep the lowest energy states and we get\n",
    "rid of the high energy states we can expect to get the low energy\n",
    "physics right. This in fact is the case in problems such as the Kondo\n",
    "and Anderson impurity problems@hewson. However, in strongly correlated,\n",
    "many-body problems such as the Heisenberg chain, this scheme performs\n",
    "poorly.\n",
    "\n",
    "The density matrix truncation: the kernel of the DMRG\n",
    "=====================================================\n",
    "\n",
    "![The DMRG modifies the NRG idea by adding a second block.<span\n",
    "data-label=\"fig:two_blocks\"></span>](figures/fig_dmrg.png)\n",
    "\n",
    "The problem was solved by Steve White by using what he called the\n",
    "‘density matrix truncation’. He realized (without knowing at the time)\n",
    "that instead of getting rid of high energy states, one has to\n",
    "redistribute the ‘entanglement’ and minimize the loss of information.\n",
    "However, the way he formulated the problem did not incorporate the idea\n",
    "of entanglement, a concept that entered the picture much later after\n",
    "quantum information ideas were used to understand why and when the DMRG\n",
    "actually works. Before introducing these ideas, we shall describe the\n",
    "original formulation of the density matrix truncation@dmrg.\n",
    "\n",
    "In order to introduce this new concept, we are going to use a new\n",
    "scheme: We are going to use two blocks instead of one, a left block, and\n",
    "a right block, as shown in Fig.\\[fig:two\\_blocks\\]. We are going to grow\n",
    "both blocks simultaneously using the same procedure outlined previously:\n",
    "at every step we add one site at the right of the left block, and one\n",
    "site to the left of the right block. The ground state can then be\n",
    "written as: $$|\\Psi\\rangle = \\sum_{i,j} \\Psi_{ij} |i\\rangle |j\\rangle,\n",
    "$$ where the sum runs over all the states of the left block\n",
    "$|i\\rangle$ and right block $|j\\rangle$, with the corresponding\n",
    "coefficients $\\Psi_{ij}$.\n",
    "\n",
    "Now the idea is as follows: once we reach the desired basis dimension\n",
    "$m$, we shall rotate the left block to a new basis\n",
    "$|i\\rangle \\rightarrow |\\alpha\\rangle$. We want to pick these states\n",
    "$|\\alpha\\rangle$ in such a way that when we truncate the basis, the\n",
    "“distance” between the original ground state $|\\Psi\\rangle$, and the\n",
    "new, truncated, variational approximation $|\\tilde{\\Psi}\\rangle$, is\n",
    "minimized: $$S=\\left||\\Psi\\rangle - |\\tilde{\\Psi}\\rangle \\right|^2,$$\n",
    "where\n",
    "$$|\\tilde{\\Psi} \\rangle = \\sum_{\\alpha=1}^m\\sum_{j} \\Psi_{\\alpha j} |\\alpha\\rangle|j\\rangle.$$\n",
    "\n",
    "We are going to anticipate the solution: pick the basis $|\\alpha\\rangle$\n",
    "given by the $m$ eigenvectors of the reduced density matrix of the left\n",
    "block with the $m$ largest eigenvalues. In order to justify this result,\n",
    "we first need to introduce some important concepts.\n",
    "The reduced density matrix\n",
    "--------------------------\n",
    "\n",
    "![In the DMRG, one block acts as the environment for the second one<span\n",
    "data-label=\"fig:partition\"></span>](figures/fig_dm.png)\n",
    "\n",
    "Imagine that we have a bipartite system, composed by subsystem $A$ and\n",
    "subsystem $B$, as shown in Fig.\\[fig:partition\\]. The Hilbert space of\n",
    "the system $A+B$ will be given by the tensor product of the Hilbert\n",
    "spaces of the two subsystems: $H_{A+B}=H_A \\otimes H_B$, and will have\n",
    "dimension $D_{A+B} = D_A\\times D_B$. Assume that the state of our system\n",
    "is described by a normalized wave-function $|\\Psi\\rangle$ that has\n",
    "support on $H_{A+B}$. We define the reduced density matrix of subsystem\n",
    "$A$ as $$\\hat{\\rho}_A = \\mathrm{Tr}_B |\\Psi\\rangle\\langle\\Psi|.$$ Its\n",
    "corresponding matrix form is\n",
    "$${\\rho_A}_{ii'} = \\langle i|\\hat{\\rho}_A|i'\\rangle = \\sum_j \\langle ij|\\Psi\\rangle\\langle \\Psi|i'j\\rangle = \\sum_{j} \\Psi_{ij}\\Psi^*_{i'j}$$\n",
    "This operator describes the density matrix of a mixed state, in which\n",
    "the system $A$ is in contact with a bath or environment $B$. This is the\n",
    "price we have to pay for our ignorance of subsystem $B$.\n",
    "\n",
    "The reduced density matrix has some nice properties:\n",
    "\n",
    "-   It is Hermitian (or symmetric in case of real matrices). This means\n",
    "    that its eigenvalues are real.\n",
    "\n",
    "-   Its eigenvalues are non-negative.\n",
    "\n",
    "-   The trace equals to unity: $\\mathrm{Tr \\rho_A} = 1$.\n",
    "\n",
    "-   Its eigenvectors $|\\alpha\\rangle$ and eigenvalues $\\omega_\\alpha$\n",
    "    form an orthonormal basis.\n",
    "\n",
    "This means that the reduced density matrix can be re-defined in the new\n",
    "eigenvector basis as:\n",
    "$$\\hat{\\rho}_A = \\sum_\\alpha \\omega_\\alpha |\\alpha\\rangle\\langle\\alpha|;$$\n",
    "with $\\omega_\\alpha \\ge 0$ and $\\sum_\\alpha {\\omega_\\alpha} = 1$.\n",
    "\n",
    "These same considerations are valid for the block $B$.\n",
    "\n",
    "The Singular Value decomposition (SVD)\n",
    "--------------------------------------\n",
    "\n",
    "Consider an arbitrary matrix $\\Psi$ of dimensions $D_A \\times D_B$. One\n",
    "can prove that $\\Psi$ can de factorized as $$\\Psi = UDV^{\\dagger},$$\n",
    "where $U$ is a ($D_A \\times D_B$) unitary matrix, $V$ is a\n",
    "$(D_B \\times D_B)$ unitary matrix, and $D$ is a $(D_B \\times D_B$\n",
    "diagonal matrix with real non-negative numbers along the diagonal, and\n",
    "zeroes elsewhere. Since $U$ and $V$ are unitary, they satisfy:\n",
    "$$\\begin{aligned}\n",
    "UU^\\dagger = {1}; \\nonumber \\\\\n",
    "VV^\\dagger = {1}. \\nonumber \\end{aligned}$$ Their columns are\n",
    "orthonormal vectors, so $U$ and $V$ can be regarded as rotation\n",
    "matrices. The diagonal matrix elements $\\lambda_\\alpha$ of $D$ are known\n",
    "as the “singular values” of $\\Psi$.\n",
    "\n",
    "The Schmidt decomposition\n",
    "-------------------------\n",
    "\n",
    "Let us apply the SVD to our quantum wave-function $|\\Psi\\rangle$\n",
    "(\\[psi\\]), and for illustration, let us assume that $D_B \\le D_A$. The\n",
    "coefficients $\\Psi_{ij}$ define a matrix $\\Psi$. After a SVD, they can\n",
    "be re-written as:\n",
    "$$\\Psi_{ij} = \\sum_\\alpha^{D_B} U_{i\\alpha}\\lambda_\\alpha(V^{\\dagger})_{\\alpha j} = \\sum_\\alpha^{D_B} U_{i\\alpha}\\lambda_\\alpha V^{*}_{\\alpha j}.$$\n",
    "The wave-function can now be expressed as: $$\\begin{aligned}\n",
    "|\\Psi\\rangle & = & \\sum_{i}^{D_A} \\sum_{j}^{D_B} \\sum_\\alpha^{D_B} U_{i\\alpha}\\lambda_\\alpha V^*_{\\alpha j}|i\\rangle|j\\rangle \\nonumber \\\\\n",
    "& = & \\sum_\\alpha^{D_B} \\left(\\sum_i^{D_A} U_{i\\alpha}|i\\rangle\\right)\\lambda_\\alpha\\left(\\sum_j^{D_B} V^*_{\\alpha j}|j\\rangle\\right) \\nonumber \\\\\n",
    "& = & \\sum_\\alpha^{D_B} \\lambda_\\alpha |\\alpha\\rangle_A|\\alpha\\rangle_B, \\nonumber\n",
    "\\end{aligned}$$ where we have defined the states\n",
    "$|\\alpha\\rangle_A = \\sum_i U_{i\\alpha}|i\\rangle$ and\n",
    "$|\\alpha\\rangle_B = \\sum_j V^*_{\\alpha j}|j\\rangle$. Due to the\n",
    "properties of $U$ and $V$, these states define a new orthogonal basis.\n",
    "This final expression is known as the “Schmidt decomposition” of the\n",
    "state $\\Psi$, and the bases ${|\\alpha\\rangle}$ as the “Schmidt bases”..\n",
    "\n",
    "In general, we have that the state $\\Psi$ can be written in the new\n",
    "basis as:\n",
    "$$|\\Psi\\rangle = \\sum_{\\alpha}^r \\lambda_\\alpha |\\alpha\\rangle_A |\\alpha\\rangle_B; \\,\\,\\, r=\\mathrm{min}(D_A,D_B).$$\n",
    "\n",
    "In the Schmidt basis, the reduced density matrices for the subsystems\n",
    "$A$ and $B$ are\n",
    "$$\\rho_A = \\mathrm{Tr}|\\Psi\\rangle\\langle\\Psi| = \\sum_\\alpha \\lambda_\\alpha^2|\\alpha\\rangle_{A}\\ _A\\langle \\alpha|,$$\n",
    "and\n",
    "$$\\rho_B = \\sum_\\alpha \\lambda_\\alpha^2|\\alpha\\rangle_{B}\\ _B\\langle \\alpha|$$\n",
    "\n",
    "At this point, we realize some interesting observations:\n",
    "\n",
    "-   The eigenvalues of the reduced density matrices are\n",
    "    $\\omega_\\alpha  = \\lambda_\\alpha^2$, the square of the\n",
    "    singular values.\n",
    "\n",
    "-   The two reduced density matrices share the spectrum.\n",
    "\n",
    "-   The Schmidt bases are the eigenvectors of the reduced\n",
    "    density matrices.\n",
    "\n",
    "Optimizing the truncated wave-function\n",
    "--------------------------------------\n",
    "\n",
    "We here go back to the original problem of optimizing the wave-function\n",
    "in a reduced basis. In order to solve it, we are going to reformulate\n",
    "the question as: Given a matrix $\\Psi$, what is the optimal matrix\n",
    "$\\tilde{\\Psi}$ with fixed rank $m$ that minimizes the Frobenius distance\n",
    "between the two matrices? It turns out, this is a well known problem\n",
    "called the “low ranking approximation”.\n",
    "\n",
    "If we order the eigenvalues of the reduced density matrix in decreasing\n",
    "order $\\omega_1,\\omega_2,...\\omega_m,...\\omega_r$, it is straightforward\n",
    "to see that the Frobenius distance between the two matrices is given by\n",
    "$$S=\\left|\\Psi - \\tilde{\\Psi}\\right|^2 = \\sum_{m+1}^r \\omega_i\n",
    "$$ This proves that the optimal basis is given by the\n",
    "eigenvectors of the reduced density matrix with the $m$ largest\n",
    "eigenvalues.\n",
    "\n",
    "Infinite-size DMRG\n",
    "==================\n",
    "\n",
    "The above considerations allow us now to introduce the DMRG algorithm in\n",
    "a very natural way. We are going to present it in the traditional\n",
    "formulation, starting with the infinite-size algorithm, followed by the\n",
    "finite-size scheme.\n",
    "\n",
    "The main idea behind the infinite-size algorithm consists in growing the\n",
    "left and right blocks by adding one site at a time. As we add sites, the\n",
    "basis of the blocks will grow, until we reach the desired maximum number\n",
    "of states $m$. At this point we need to start applying the density\n",
    "matrix truncation on both blocks. This process is repeated until we\n",
    "reach a desired system-size, or the error in the energy is below a\n",
    "pre-defined tolerance.\n",
    "\n",
    "![Step-by-step illustration of the block-growing scheme in the\n",
    "infinite-size DMRG algorithm: After obtaining the new blocks from the\n",
    "previous step (a), we add a new site to each block (b), we build the\n",
    "superblock and obtain the ground-state (c), and we calculate the reduced\n",
    "density-matrix, and rotate to the basis of the eigenvectors with $m$\n",
    "largest eigenvalues to build the new blocks for the next step (d).\n",
    "](figures/fig_infinite.png \"fig:\") \\[fig:infinite\\]\n",
    "\n",
    "The algorithm illustrated in Fig.\\[fig:infinite\\] could be outlined as\n",
    "below:\n",
    "\n",
    "* Build all the operator matrices for a single-site Hamiltonian, and the operators involved in the interactions between the site an the rest of the system.\n",
    "* Start growing the blocks by adding single-sites, as outlined in the exact diagonalization section. We assume that the Hilbert space for the single site has dimension $d$.  When the size of the bocks become larger than $d \\times m$, we start applying the density matrix truncation as follows:\n",
    "\n",
    "    1. Using a suitable library routine (Lanczos,Davidson), diagonalize the full Hamiltonian (sometimes called super-Hamiltonian) of the two blocks combined (sometimes refereed to as superblock), to obtain the ground state $$|\\Psi\\rangle = \\sum_{ij}\\Psi_{ij}|i\\rangle|j\\rangle$$.\n",
    "    2. Calculate the reduced density matrix of the left block, and right blocks. When the system is symmetric under reflections, we only need one of them.\n",
    "    3. For each of the blocks, diagonalize the density matrix to obtain the full spectrum and eigenvectors.\n",
    "    4. Truncate the basis by keeping only the $m$ eigenvectors with the largest eigenvalues.\n",
    "    5. Rotate the Hamiltonian and the operators involved in the interactions between blocks to the new basis.\n",
    "    6. Add a new site to the left and right blocks, to build new blocks of dimension $d \\times m$, and reiterate the diagonalization and truncation steps. Stop when we reach the desired system-size, or the error in the energy is below a pre-defined tolerance.\n",
    "    \n",
    "In the early days of DMRG it was assumed that this scheme would lead to\n",
    "a good approximation of the system properties in the thermodynamic\n",
    "limit. Today we know that he best way to reach the thermodynamic limit\n",
    "is by using the finite-size algorithm on systems of fixed length, and\n",
    "doing a careful finite-size analysis of the results.\n",
    "\n",
    "Let us now explain some of these steps in more detail.\n",
    "\n",
    "Adding a single site to the block\n",
    "---------------------------------\n",
    "\n",
    "![Adding sites to the blocks is done in the same way as in the\n",
    "NRG.](figures/fig_add_left.png \"fig:\") ![Adding sites to the blocks is\n",
    "done in the same way as in the NRG.](figures/fig_add_right.png \"fig:\")\n",
    "\\[fig:add\\_site\\]\n",
    "\n",
    "Same as we did in the exact diagonalization section, we can add sites to\n",
    "the blocks by performing tensor products of the “tilde” operators on the\n",
    "block, and single-site operators.\n",
    "\n",
    "Assume that we are in the $i^\\mathrm{th}$ iteration of the algorithm,\n",
    "with our left and right blocks having length $i$. Let us label our $D_L$\n",
    "basis states for the left block $\\{|\\alpha_{i}\\rangle \\}$, and our $d$\n",
    "basis states for the single site that comes to the right\n",
    "$\\{|s_{i+1}\\rangle \\}$ (See Fig.\\[fig:add\\_site\\]). When we add the site\n",
    "to the block, we obtain a new basis for the new combined block as\n",
    "$|\\alpha_{i+1}\\rangle = |\\alpha_i\\rangle \\otimes |s_{i+1}\\rangle$.\n",
    "\n",
    "Let us assume for illustration purposes that we are dealing once more\n",
    "with the Heisenberg chain. All these ideas can be easily generalized to\n",
    "arbitrary models. Same as we did in the exact diagonalization section,\n",
    "we obtain the new Hamiltonian matrix for the combined block as:\n",
    "$$H_{L,i+1} = H_{L,i} \\otimes {1}_2 + \\tilde{S}^z_{L,i} \\otimes S^z + \\frac{1}{2} \\left( \\tilde{S}^+_{L,i} \\otimes S^- + \\tilde{S}^-_{L,i} \\otimes S^+ \\right).$$\n",
    "In this expression, the “tilde” operators are in the $|\\alpha_i\\rangle$\n",
    "basis, while the others are defined in the single-site basis.\n",
    "\n",
    "A similar expression applies to the right block, which is obtained from\n",
    "the single site at position $i+2$, with basis $\\{|s_{i+2}\\rangle\\}$ and\n",
    "dimension $d$, and the right block with basis $\\{|\\beta_{i+3}\\rangle\\}$\n",
    "and dimension $D_R$:\n",
    "$$H_{R,i+2} = {1}_2 \\otimes H_{R,i+3} + S^z \\otimes \\tilde{S}^z_{R,i+3} + \\frac{1}{2} \\left( {S^+} \\otimes \\tilde{S}^-_{R,i+3} + {S^-} \\otimes \\tilde{S}^+_{R,i+3} \\right).$$\n",
    "\n",
    "\n",
    "Building the super-Hamiltonian\n",
    "------------------------------\n",
    "\n",
    "We now need to combine the left and right blocks to form the\n",
    "super-Hamiltonian:\n",
    "$$\\hat{H}=\\hat{H}_{L,i+1}+\\hat{H}_{R,i+2} + S^z_{i+1} S^z_{i+2} + \\frac{1}{2}\\left( S^+_{i+1}S^-_{i+2} + S^-_{i+1}S^+_{i+2} \\right)$$\n",
    "where $\\hat{H}_{L(R)}$ where obtained above, and only involve terms in\n",
    "the left (right) block. The single sites at positions $i+1$ and $i+2$\n",
    "were absorbed by the left and right blocks, respectively, so in order to\n",
    "build the interactions, we have to rotate the corresponding operators to\n",
    "the new basis of the blocks. This is again done in the same spirit of\n",
    "the “tilde” transformation: \n",
    "$$\\begin{aligned}\n",
    "H & = & H_{L,i+1} \\otimes {1}_{D_R\\times2} + {1}_{D_L \\times 2} \\otimes H_{R,i+2} \\nonumber \\\\\n",
    "& + & {1}_{D_L} \\otimes S^z \\otimes S^z \\otimes {1}_{D_R} \\nonumber \\\\\n",
    "& + & \\frac{1}{2} {1}_{D_L} \\otimes S^+ \\otimes S^- \\otimes {1}_{D_R} \\nonumber \\\\\n",
    "& + & \\frac{1}{2} {1}_{D_L} \\otimes S^- \\otimes S^+ \\otimes {1}_{D_R} \\nonumber\\end{aligned}$$\n",
    "or: $$\\begin{aligned}\n",
    "H & = & H_{L,i+1} \\otimes {1}_{D_R\\times2} + {1}_{D_L \\times 2} \\otimes H_{R,i+2} \\nonumber \\\\\n",
    "& + & \\tilde{S}^z_{L,i+1} \\otimes \\tilde{S}^z_{R,i+2} \\nonumber \\\\\n",
    "& + & \\frac{1}{2} \\tilde{S}^+_{L,i+1} \\otimes \\tilde{S}^-_{R,i+2} \\nonumber \\\\\n",
    "& + & \\frac{1}{2} \\tilde{S}^-_{L,i+1} \\otimes \\tilde{S}^+_{R,i+2} \\nonumber \\end{aligned}$$\n",
    "\n",
    "\n",
    "Density matrix truncation and the rotation to the new basis\n",
    "-----------------------------------------------------------\n",
    "\n",
    "The truncation process is similar to the one use in numerical\n",
    "renormalization group, but instead of using the matrix of eigenvectors\n",
    "of the Hamiltonian, we use the eigenvectors\n",
    "$\\{|\\alpha\\rangle\\},\\{|\\beta\\rangle\\}$ of the left and right reduced\n",
    "density matrix. Therefore, the new basis states for the left and right\n",
    "block are related to the states in the previous step as:\n",
    "$$\\begin{aligned}\n",
    "|\\alpha_{i+1}\\rangle & = & \\sum_{s_{i+1},\\alpha_i}\\langle \\alpha_i s_{i+1}|\\alpha_{i+1} \\rangle |\\alpha_i s_{i+1} \\rangle  =\n",
    "\\sum_{s_{i+1},\\alpha_i} (U_L)_{\\alpha_i s_{i+1},\\alpha_{i+1}} | \\alpha_i s_{i+1} \\rangle \\nonumber \\\\\n",
    "|\\beta_{i+2}\\rangle & = & \\sum_{s_{i+2},\\beta_{i+3}}\\langle s_{i+2} \\beta_{i+3}|\\beta_{i+2} \\rangle |s_{i+2} \\beta_{i+3} \\rangle\n",
    "= \\sum_{s_{i+2},\\beta_{i+3}} (U_R)_{s_{i+2} \\beta_{i+3},\\beta_{i+2}} | s_{i+2} \\beta_{i+3} \\rangle\\end{aligned}$$\n",
    "where\n",
    "$$(U_L)_{\\alpha_i s_{i+1},\\alpha_{i+1}} = \\langle \\alpha_i s_{i+1}|\\alpha_{i+1} \\rangle$$\n",
    "and\n",
    "$$(U_R)_{s_{i+2} \\beta_{i+3},\\beta_{i+2}} = \\langle s_{i+2} \\beta_{i+3}|\\beta_{i+2} \\rangle.$$\n",
    "If we keep only $m$ states, the matrices $U_{L(R)}$ will have dimensions\n",
    "$D_{L(R)} d\\times m$. If the basis had already been truncated in the\n",
    "previous step, then $D_L(R)=m$.\n",
    "\n",
    "We can now use these transformations to obtain the matrix elements for\n",
    "all the operators in the new truncated basis. For instance, an operator\n",
    "acting on a site inside the left block will be transformed as:\n",
    "$$\\begin{aligned}\n",
    "(\\tilde{O}_{L,i+1})_{\\alpha_{i+1},\\alpha'_{i+1}} & = & \\langle \\alpha_{i+1} |\\hat{O}|\\alpha'_{i+1}\\rangle \\nonumber \\\\\n",
    "& = & \\sum_{\\alpha_i,s_{i+1}} \\sum_{\\alpha'_i,s'_{i+1}} \\langle \\alpha_{i+1}|\\alpha_i s_{i+1}\\rangle\\langle \\alpha_i s_{i+1}|\\hat{O}|\\alpha'_i s'_{i+1}\\rangle\\langle \\alpha'_i s'_{i+1}|\\alpha'_{i+1}\\rangle \\nonumber \\\\\n",
    "& = & \\sum_{\\alpha_i s_{i+1}}\\sum_{\\alpha'_i s'_{i+1}} (U_L^\\dagger)_{\\alpha_{i+1},\\alpha_is_{i+1}} (\\tilde{O_{L,i}})_{\\alpha_i s_{i+1},\\alpha'_i s'_{i+1}} (U_L)_{\\alpha'_is'_{i+1},\\alpha'_{i+1}},\\end{aligned}$$\n",
    "and a similar expression can be obtained for operators in the right\n",
    "block.\n",
    "\n",
    "The Finite-size DMRG\n",
    "====================\n",
    "\n",
    "![Schematic illustration of the finite-size DMRG algorithm: The\n",
    "infinite-size iteration stops when we reach the desired system size.\n",
    "Then, we start sweeping from left to right, and right to left. During\n",
    "the sweeping iterations, one block grows, and the other one “shrinks”.\n",
    "The shrinking block is retrieved from the blocks obtained in the\n",
    "previous sweep in the opposite direction, which are stored in memory or\n",
    "disk.](figures/fig_finite.png \"fig:\") \\[fig:finite\\]\n",
    "\n",
    "As we mentioned before, the proper way to reach the thermodynamic limit\n",
    "with DMRG is by studying finite systems and performing a finite-size\n",
    "analysis. In order to study finite system, a generalization of the above\n",
    "ideas needs to be applied. The finite-size DMRG (illustrated in\n",
    "Fig.\\[fig:finite\\]) can be summarized as follows:\n",
    "\n",
    "* Run the infinite-size algorithm until the desired system size is reached.\n",
    "During this process, store all the left and right blocks, with their corresponding operators and basis transformations. This step is typically referred to as the ``warmup''.\n",
    "* Once the desired system size is reached we start performing ``DMRG sweeps'', from right-to-left, and left-to-right to optimize the bases and improve accuracy. A left-to-right sweep is described as follows:\n",
    "\n",
    "    1. Add a site to the left block using the same idea of the infinite-size DMRG. Since the total size of the system needs to be kept fixed, we need to ``shrink'' the right block. This is done by using the smaller right block from the infinite-size step, or from the previous right-to-left sweep.\n",
    "    2. Using a suitable library routine (Lanczos,Davidson), diagonalize the super Hamiltonian (sometimes called super-Hamiltonian) of the two blocks combined, same as for the infinite-size DMRG.\n",
    "    3. Calculate the reduced density matrix of the left block.\n",
    "    4. Diagonalize the density matrix to obtain the full spectrum and eigenvectors.\n",
    "    5. Truncate the basis by keeping only the $m$ eigenvectors with the largest eigenvalues.\n",
    "    6. Rotate the Hamiltonian and the operators of the left block involved in the interactions between blocks to the new basis.\n",
    "    7. Iterate until reaching the far right end of the system, with a right block containing a single site. This completes the left-to-right sweep.\n",
    "\n",
    "* Perform a right-to-left sweep, by growing the right block one site at a time, and using the left block from the previous left-to-right sweep.\n",
    "* Re-iterate the sweeping. Stop when the change in the energy is below a pre-defined tolerance. One typically stops at a point when both blocks have the same size, the ``symmetric configuration''.\n",
    "\n",
    "This sweeping process works in a similar fashion as a self-consistent\n",
    "loop, where we iteratively improve the solution. In fact, the DMRG can\n",
    "be formulated as a variational method, in which the variational\n",
    "parameters are continuously improved to minimize an energy functional.\n",
    "Intuitively a way to see it is by imagining a “demon” probing the\n",
    "environment around the block for the optimal states to improve the basis\n",
    "to represent the ground-state. These states are “absorbed” inside the\n",
    "block by the density matrix and its eigenvectors.\n",
    "\n",
    "As described above, the shrinking block is replaced by the block from\n",
    "the previous sweep in the opposite direction. This means that all the\n",
    "information about the block and its operators needs to be stored, either\n",
    "in memory, or dumped on disk or stored in memory.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def psi_dot_psi(psi1, psi2):\n",
    "    x = 0.\n",
    "    for i in range(psi1.shape[0]):\n",
    "        for j in range(psi2.shape[1]):\n",
    "            x += psi1[i,j]*psi2[i,j]\n",
    "    return x\n",
    "            \n",
    "def lanczos(m, seed, maxiter, tol, use_seed = False, force_maxiter = False):\n",
    "    x1 = seed\n",
    "    x2 = seed\n",
    "    gs = seed\n",
    "    a = np.zeros(100)\n",
    "    b = np.zeros(100)\n",
    "    z = np.zeros((100,100))\n",
    "    lvectors = []\n",
    "    control_max = maxiter;\n",
    "    e0 = 9999\n",
    "\n",
    "    if(maxiter == -1):\n",
    "        force_maxiter = False\n",
    "\n",
    "    if(control_max == 0):\n",
    "        gs = 1\n",
    "        maxiter = 1\n",
    "        return(e0,gs)\n",
    "    \n",
    "    x1[:,:] = 0\n",
    "    x2[:,:] = 0\n",
    "    gs[:,:] = 0\n",
    "    a[:] = 0.0\n",
    "    b[:] = 0.0\n",
    "    if(use_seed):\n",
    "        x1 = seed\n",
    "    else:\n",
    "        for i in range(x1.shape[0]):\n",
    "            for j in range(x1.shape[1]):\n",
    "                x1[i,j] = (2*np.random.random()-1.)\n",
    "\n",
    "#    x1[:,:] = 1\n",
    "    b[0] = psi_dot_psi(x1,x1)\n",
    "    b[0] = np.sqrt(b[0])\n",
    "    x1 = x1 / b[0]\n",
    "    x2[:] = 0\n",
    "    b[0] = 1.\n",
    "\n",
    "    e0 = 9999\n",
    "    nmax = min(99, maxiter)\n",
    "\n",
    "    for iter in range(1,nmax+1):\n",
    "        eini = e0\n",
    "        if(b[iter - 1] != 0.):\n",
    "            aux = x1\n",
    "            x1 = -b[iter-1] * x2\n",
    "            x2 = aux / b[iter-1]\n",
    "\n",
    "        aux = m.product(x2)\n",
    "\n",
    "        x1 = x1 + aux\n",
    "        a[iter] = psi_dot_psi(x1,x2)\n",
    "        x1 = x1 - x2*a[iter]\n",
    "\n",
    "        b[iter] = psi_dot_psi(x1,x1)\n",
    "        b[iter] = np.sqrt(b[iter])\n",
    "        lvectors.append(x2)                                                  \n",
    "#        print \"Iter =\",iter,a[iter],b[iter]\n",
    "        z.resize((iter,iter))\n",
    "        z[:,:] = 0\n",
    "        for i in range(0,iter-1):\n",
    "            z[i,i+1] = b[i+1]\n",
    "            z[i+1,i] = b[i+1]\n",
    "            z[i,i] = a[i+1]\n",
    "        z[iter-1,iter-1]=a[iter]\n",
    "        d, v = np.linalg.eig(z)\n",
    "\n",
    "        col = 0\n",
    "        n = 0\n",
    "        e0 = 9999\n",
    "        for e in d:\n",
    "            if(e < e0):\n",
    "                e0 = e\n",
    "                col = n\n",
    "            n+=1\n",
    "        e0 = d[col]\n",
    "        \n",
    "       \n",
    "        print \"Iter = \",iter,\" Ener = \",e0\n",
    "        if((force_maxiter and iter >= control_max) or (iter >= gs.shape[0]*gs.shape[1] or iter == 99 or abs(b[iter]) < tol) or \\\n",
    "            ((not force_maxiter) and abs(eini-e0) <= tol)):\n",
    "            # converged\n",
    "            gs[:,:] = 0.\n",
    "            for n in range(0,iter):\n",
    "                gs += v[n,col]*lvectors[n]\n",
    "\n",
    "            print \"E0 = \", e0\n",
    "            maxiter = iter\n",
    "            return(e0,gs) # We return with ground states energy\n",
    "\n",
    "    return(e0,gs)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "class Position:\n",
    "    LEFT, RIGHT = range(2)\n",
    "\n",
    "class DMRGSystem(object): \n",
    "\n",
    "    def __init__(self, _nsites):\n",
    "\n",
    "        #Single site operators\n",
    "        self.nsites = _nsites\n",
    "        self.nstates = 2\n",
    "        self.dim_l = 0      # dimension of the left block\n",
    "        self.dim_r = 0      # dimension of the right block\n",
    "        self.left_size = 0  # number of sites in the left block\n",
    "        self.right_size = 0 # number of sites in the right block\n",
    "\n",
    "        self.sz0 = np.zeros(shape=(2,2)) # single site Sz\n",
    "        self.splus0 = np.zeros(shape=(2,2)) # single site S+\n",
    "        self.sz0[0,0]         = -0.5\n",
    "        self.sz0[1,1]         =  0.5\n",
    "        self.splus0[1,0]      =  1.0\n",
    "\n",
    "        #Useful structures to store the matrices\n",
    "\n",
    "        self.HL = []     # left block Hamiltonian\n",
    "        self.HR = []     # right block Hamiltonian\n",
    "        self.szL = []    # left block Sz\n",
    "        self.szR = []    # right block Sz\n",
    "        self.splusL = [] # left block S+\n",
    "        self.splusR = [] # right block S+\n",
    "\n",
    "        zero_matrix = np.zeros(shape=(2,2))\n",
    "        for i in range(nsites):\n",
    "            self.HL.append(zero_matrix)\n",
    "            self.HR.append(zero_matrix)\n",
    "            self.szL.append(self.sz0)\n",
    "            self.szR.append(self.sz0)\n",
    "            self.splusL.append(self.splus0)\n",
    "            self.splusR.append(self.splus0)\n",
    "\n",
    "        self.psi = np.zeros(shape=(2,2)) # g.s. wave function\n",
    "        self.rho = np.zeros(shape=(2,2)) # density matrix\n",
    "\n",
    "        self.energy = 0.\n",
    "        self.error = 0.\n",
    "\n",
    "#######################################\n",
    "\n",
    "\n",
    "    def BuildBlockLeft(self, iter):\n",
    "        self.left_size = iter\n",
    "        self.dim_l = self.HL[self.left_size-1].shape[0]\n",
    "        I_left = np.eye(self.dim_l)\n",
    "        I2 = np.eye(2)\n",
    "        # enlarge left block:\n",
    "        self.HL[self.left_size] = np.kron(self.HL[self.left_size-1],I2) + \\\n",
    "                         np.kron(self.szL[self.left_size-1],self.sz0) + \\\n",
    "                         0.5*np.kron(self.splusL[self.left_size-1],self.splus0.transpose()) + \\\n",
    "                         0.5*np.kron(self.splusL[self.left_size-1].transpose(),self.splus0)\n",
    "        self.splusL[self.left_size] = np.kron(I_left,self.splus0)\n",
    "        self.szL[self.left_size] = np.kron(I_left,self.sz0)\n",
    "\n",
    "    def BuildBlockRight(self, iter):\n",
    "        self.right_size = iter\n",
    "        self.dim_r = self.HR[self.right_size-1].shape[0]\n",
    "        I_right= np.eye(self.dim_r)\n",
    "        I2 = np.eye(2)\n",
    "        # enlarge right block:\n",
    "        self.HR[self.right_size] = np.kron(I2,self.HR[self.right_size-1]) + \\\n",
    "                         np.kron(self.sz0,self.szR[self.right_size-1]) + \\\n",
    "                         0.5* np.kron(self.splus0.transpose(),self.splusR[self.right_size-1]) + \\\n",
    "                         0.5* np.kron(self.splus0,self.splusR[self.right_size-1].transpose())\n",
    "        self.splusR[self.right_size] = np.kron(self.splus0,I_right)\n",
    "        self.szR[self.right_size] = np.kron(self.sz0,I_right)\n",
    "\n",
    "    \n",
    "    def GroundState(self):\n",
    "        self.dim_l = self.HL[self.left_size].shape[0]\n",
    "        self.dim_r = self.HR[self.right_size].shape[0]\n",
    "        self.psi.resize((self.dim_l,self.dim_r))\n",
    "        maxiter = self.dim_l*self.dim_r\n",
    "        (self.energy, self.psi) = lanczos(self, self.psi, maxiter, 1.e-7)\n",
    "\n",
    "\n",
    "    def DensityMatrix(self, position):\n",
    "        # Calculate density matrix\n",
    "        if(position == Position.LEFT):\n",
    "            self.rho = np.dot(self.psi,self.psi.transpose())\n",
    "        else: \n",
    "            self.rho = np.dot(self.psi.transpose(),self.psi)\n",
    "\n",
    "               \n",
    "    def Truncate(self, position, m):\n",
    "        # diagonalize rho\n",
    "        rho_eig, rho_evec = np.linalg.eigh(self.rho)\n",
    "        self.nstates = m\n",
    "        rho_evec = np.real(rho_evec)\n",
    "        rho_eig = np.real(rho_eig)\n",
    "\n",
    "        # calculate the truncation error for a given number of states m\n",
    "        # Reorder eigenvectors and trucate\n",
    "        index = np.argsort(rho_eig)\n",
    "        for e in index:\n",
    "            print \"RHO EIGENVALUE \", rho_eig[e]\n",
    "        error = 0.\n",
    "        if (m < rho_eig.shape[0]):\n",
    "            for i in range(index.shape[0]-m):\n",
    "                error += rho_eig[index[i]]\n",
    "        print \"Truncation error = \", error\n",
    "\n",
    "        aux = np.copy(rho_evec)\n",
    "        if (self.rho.shape[0] > m):\n",
    "            aux.resize((aux.shape[0],m))\n",
    "            n = 0\n",
    "            for i in range(index.shape[0]-1,index.shape[0]-1-m,-1):\n",
    "                aux[:,n]=rho_evec[:,index[i]]\n",
    "                n += 1\n",
    "        rho_evec = aux       \n",
    "\n",
    "#        rho_evec = np.eye(self.rho.shape[0])\n",
    "\n",
    "        # perform transformation:\n",
    "        U = rho_evec.transpose()\n",
    "        if(position == Position.LEFT):\n",
    "            aux2 = np.dot(self.HL[self.left_size],rho_evec)\n",
    "            self.HL[self.left_size] = np.dot(U,aux2)\n",
    "            aux2 = np.dot(self.splusL[self.left_size],rho_evec)\n",
    "            self.splusL[self.left_size] = np.dot(U,aux2)\n",
    "            aux2 = np.dot(self.szL[self.left_size],rho_evec)\n",
    "            self.szL[self.left_size] = np.dot(U,aux2)\n",
    "        else:\n",
    "            aux2 = np.dot(self.HR[self.right_size],rho_evec)\n",
    "            self.HR[self.right_size] = np.dot(U,aux2)\n",
    "            aux2 = np.dot(self.splusR[self.right_size],rho_evec)\n",
    "            self.splusR[self.right_size] = np.dot(U,aux2)\n",
    "            aux2 = np.dot(self.szR[self.right_size],rho_evec)\n",
    "            self.szR[self.right_size] = np.dot(U,aux2)\n",
    "               \n",
    "    def product(self, psi):\n",
    "        npsi = np.dot(self.HL[self.left_size],psi)\n",
    "        npsi += np.dot(psi,self.HR[self.right_size].transpose())\n",
    "\n",
    "        # Sz.Sz\n",
    "        tmat = np.dot(psi,self.szR[self.right_size].transpose())\n",
    "        npsi += np.dot(self.szL[self.left_size],tmat)\n",
    "        # S+.S-\n",
    "        tmat = np.dot(psi,self.splusR[self.right_size])*0.5\n",
    "        npsi += np.dot(self.splusL[self.left_size],tmat)\n",
    "        # S-.S+\n",
    "        tmat = np.dot(psi,self.splusR[self.right_size].transpose())*0.5\n",
    "        npsi += np.dot(self.splusL[self.left_size].transpose(),tmat)\n",
    "\n",
    "        return npsi\n",
    "               \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARMUP ITERATION  1 0 0\n",
      "Iter =  1  Ener =  0.461465177848\n",
      "Iter =  2  Ener =  -0.723470145128\n",
      "Iter =  3  Ener =  -0.955796185995\n",
      "Iter =  4  Ener =  -1.09440427122\n",
      "Iter =  5  Ener =  -1.60690967069\n",
      "Iter =  6  Ener =  -1.61602540378\n",
      "E0 =  -1.61602540378\n",
      "RHO EIGENVALUE  0.0223290993693\n",
      "RHO EIGENVALUE  0.0223290993693\n",
      "RHO EIGENVALUE  0.0223290993693\n",
      "RHO EIGENVALUE  0.933012701892\n",
      "Truncation error =  0.0\n",
      "RHO EIGENVALUE  0.0223290993693\n",
      "RHO EIGENVALUE  0.0223290993693\n",
      "RHO EIGENVALUE  0.0223290993693\n",
      "RHO EIGENVALUE  0.933012701892\n",
      "Truncation error =  0.0\n",
      "WARMUP ITERATION  2 4 4\n",
      "Iter =  1  Ener =  -0.0168553717681\n",
      "Iter =  2  Ener =  -1.09899996345\n",
      "Iter =  3  Ener =  -1.69165575266\n",
      "Iter =  4  Ener =  -2.11182285272\n",
      "Iter =  5  Ener =  -2.2704178049\n",
      "Iter =  6  Ener =  -2.41535627015\n",
      "Iter =  7  Ener =  -2.47627242237\n",
      "Iter =  8  Ener =  -2.49131421353\n",
      "Iter =  9  Ener =  -2.49342510535\n",
      "Iter =  10  Ener =  -2.49357085847\n",
      "Iter =  11  Ener =  -2.49357678533\n",
      "Iter =  12  Ener =  -2.49357711846\n",
      "Iter =  13  Ener =  -2.49357713303\n",
      "E0 =  -2.49357713303\n",
      "RHO EIGENVALUE  8.76360039152e-05\n",
      "RHO EIGENVALUE  8.7639150371e-05\n",
      "RHO EIGENVALUE  8.76539724154e-05\n",
      "RHO EIGENVALUE  8.76706477776e-05\n",
      "RHO EIGENVALUE  0.00103360228664\n",
      "RHO EIGENVALUE  0.00103402590633\n",
      "RHO EIGENVALUE  0.498790137297\n",
      "RHO EIGENVALUE  0.498791634735\n",
      "Truncation error =  0.0\n",
      "RHO EIGENVALUE  8.76360039152e-05\n",
      "RHO EIGENVALUE  8.7639150371e-05\n",
      "RHO EIGENVALUE  8.76539724154e-05\n",
      "RHO EIGENVALUE  8.76706477776e-05\n",
      "RHO EIGENVALUE  0.00103360228664\n",
      "RHO EIGENVALUE  0.00103402590633\n",
      "RHO EIGENVALUE  0.498790137297\n",
      "RHO EIGENVALUE  0.498791634735\n",
      "Truncation error =  0.0\n",
      "WARMUP ITERATION  3 8 8\n",
      "Iter =  1  Ener =  -0.0424576156819\n",
      "Iter =  2  Ener =  -1.55304343806\n",
      "Iter =  3  Ener =  -2.45853106926\n",
      "Iter =  4  Ener =  -2.8050844371\n",
      "Iter =  5  Ener =  -2.94173438403\n",
      "Iter =  6  Ener =  -2.98215252289\n",
      "Iter =  7  Ener =  -3.00732505654\n",
      "Iter =  8  Ener =  -3.07020894528\n",
      "Iter =  9  Ener =  -3.23114608439\n",
      "Iter =  10  Ener =  -3.34057465541\n",
      "Iter =  11  Ener =  -3.36962137673\n",
      "Iter =  12  Ener =  -3.37412344975\n",
      "Iter =  13  Ener =  -3.37480262498\n",
      "Iter =  14  Ener =  -3.37491947172\n",
      "Iter =  15  Ener =  -3.37493110069\n",
      "Iter =  16  Ener =  -3.37493233631\n",
      "Iter =  17  Ener =  -3.37493254439\n",
      "Iter =  18  Ener =  -3.37493259144\n",
      "E0 =  -3.37493259144\n",
      "RHO EIGENVALUE  2.76989491512e-08\n",
      "RHO EIGENVALUE  2.95707168834e-08\n",
      "RHO EIGENVALUE  3.00826592207e-08\n",
      "RHO EIGENVALUE  3.09608758091e-08\n",
      "RHO EIGENVALUE  3.21592195365e-08\n",
      "RHO EIGENVALUE  1.86872445746e-07\n",
      "RHO EIGENVALUE  1.9017028816e-07\n",
      "RHO EIGENVALUE  1.92762119685e-07\n",
      "RHO EIGENVALUE  4.14172008423e-06\n",
      "RHO EIGENVALUE  1.64241513425e-05\n",
      "RHO EIGENVALUE  1.64601927258e-05\n",
      "RHO EIGENVALUE  1.64908772633e-05\n",
      "RHO EIGENVALUE  0.0355088438246\n",
      "RHO EIGENVALUE  0.0355123855625\n",
      "RHO EIGENVALUE  0.0355144932391\n",
      "RHO EIGENVALUE  0.893410040155\n",
      "Truncation error =  3.37344866347e-07\n",
      "RHO EIGENVALUE  2.76989491874e-08\n",
      "RHO EIGENVALUE  2.95707169506e-08\n",
      "RHO EIGENVALUE  3.00826592702e-08\n",
      "RHO EIGENVALUE  3.0960875847e-08\n",
      "RHO EIGENVALUE  3.21592195741e-08\n",
      "RHO EIGENVALUE  1.86872445785e-07\n",
      "RHO EIGENVALUE  1.90170288209e-07\n",
      "RHO EIGENVALUE  1.92762119689e-07\n",
      "RHO EIGENVALUE  4.14172008423e-06\n",
      "RHO EIGENVALUE  1.64241513425e-05\n",
      "RHO EIGENVALUE  1.64601927258e-05\n",
      "RHO EIGENVALUE  1.64908772633e-05\n",
      "RHO EIGENVALUE  0.0355088438246\n",
      "RHO EIGENVALUE  0.0355123855625\n",
      "RHO EIGENVALUE  0.0355144932391\n",
      "RHO EIGENVALUE  0.893410040155\n",
      "Truncation error =  3.37344866614e-07\n",
      "WARMUP ITERATION  4 16 16\n",
      "Iter =  1  Ener =  -0.672221865349\n",
      "Iter =  2  Ener =  -2.015188323\n",
      "Iter =  3  Ener =  -2.9351194045\n",
      "Iter =  4  Ener =  -3.52170600601\n",
      "Iter =  5  Ener =  -3.81855209186\n",
      "Iter =  6  Ener =  -3.93210644247\n",
      "Iter =  7  Ener =  -3.98738969545\n",
      "Iter =  8  Ener =  -4.04568053989\n",
      "Iter =  9  Ener =  -4.13962248169\n",
      "Iter =  10  Ener =  -4.20765042167\n",
      "Iter =  11  Ener =  -4.24269605555\n",
      "Iter =  12  Ener =  -4.25456039584\n",
      "Iter =  13  Ener =  -4.25733481573\n",
      "Iter =  14  Ener =  -4.25789790504\n",
      "Iter =  15  Ener =  -4.2580043783\n",
      "Iter =  16  Ener =  -4.25802539979\n",
      "Iter =  17  Ener =  -4.25802853876\n",
      "Iter =  18  Ener =  -4.25802881481\n",
      "Iter =  19  Ener =  -4.25802885374\n",
      "E0 =  -4.25802885374\n",
      "RHO EIGENVALUE  2.93637757538e-12\n",
      "RHO EIGENVALUE  4.55100392465e-11\n",
      "RHO EIGENVALUE  6.2389593961e-11\n",
      "RHO EIGENVALUE  1.10333930788e-10\n",
      "RHO EIGENVALUE  2.4306007194e-09\n",
      "RHO EIGENVALUE  2.71042677015e-09\n",
      "RHO EIGENVALUE  2.87656716333e-08\n",
      "RHO EIGENVALUE  3.34199444045e-08\n",
      "RHO EIGENVALUE  3.67333361513e-08\n",
      "RHO EIGENVALUE  3.76328282891e-08\n",
      "RHO EIGENVALUE  3.99442489633e-07\n",
      "RHO EIGENVALUE  4.04763414744e-07\n",
      "RHO EIGENVALUE  0.000272918859686\n",
      "RHO EIGENVALUE  0.000274065150863\n",
      "RHO EIGENVALUE  0.000274860422055\n",
      "RHO EIGENVALUE  0.000275001617731\n",
      "RHO EIGENVALUE  0.00286712943923\n",
      "RHO EIGENVALUE  0.00286863113667\n",
      "RHO EIGENVALUE  0.496551074115\n",
      "RHO EIGENVALUE  0.496615373139\n",
      "Truncation error =  1.41913977909e-07\n",
      "RHO EIGENVALUE  2.936377553e-12\n",
      "RHO EIGENVALUE  4.55100392596e-11\n",
      "RHO EIGENVALUE  6.23895940452e-11\n",
      "RHO EIGENVALUE  1.1033393067e-10\n",
      "RHO EIGENVALUE  2.43060072162e-09\n",
      "RHO EIGENVALUE  2.71042676972e-09\n",
      "RHO EIGENVALUE  2.87656716329e-08\n",
      "RHO EIGENVALUE  3.34199444028e-08\n",
      "RHO EIGENVALUE  3.67333361522e-08\n",
      "RHO EIGENVALUE  3.76328282902e-08\n",
      "RHO EIGENVALUE  3.99442489665e-07\n",
      "RHO EIGENVALUE  4.0476341473e-07\n",
      "RHO EIGENVALUE  0.000272918859686\n",
      "RHO EIGENVALUE  0.000274065150863\n",
      "RHO EIGENVALUE  0.000274860422055\n",
      "RHO EIGENVALUE  0.000275001617731\n",
      "RHO EIGENVALUE  0.00286712943923\n",
      "RHO EIGENVALUE  0.00286863113667\n",
      "RHO EIGENVALUE  0.496551074115\n",
      "RHO EIGENVALUE  0.496615373139\n",
      "Truncation error =  1.41913977911e-07\n",
      "LEFT-TO-RIGHT ITERATION  5 20 20\n",
      "Iter =  1  Ener =  -1.03082776759\n",
      "Iter =  2  Ener =  -2.40739234103\n",
      "Iter =  3  Ener =  -3.25141996115\n",
      "Iter =  4  Ener =  -3.63036665913\n",
      "Iter =  5  Ener =  -3.83296088232\n",
      "Iter =  6  Ener =  -3.90820875384\n",
      "Iter =  7  Ener =  -3.95660918123\n",
      "Iter =  8  Ener =  -4.01053211652\n",
      "Iter =  9  Ener =  -4.08817129471\n",
      "Iter =  10  Ener =  -4.19883592985\n",
      "Iter =  11  Ener =  -4.24564044546\n",
      "Iter =  12  Ener =  -4.25597410611\n",
      "Iter =  13  Ener =  -4.25771618551\n",
      "Iter =  14  Ener =  -4.25799476018\n",
      "Iter =  15  Ener =  -4.25802689693\n",
      "Iter =  16  Ener =  -4.25803092221\n",
      "Iter =  17  Ener =  -4.25803137911\n",
      "Iter =  18  Ener =  -4.25803146489\n",
      "E0 =  -4.25803146489\n",
      "RHO EIGENVALUE  -5.94439264521e-18\n",
      "RHO EIGENVALUE  -4.19838882699e-19\n",
      "RHO EIGENVALUE  -7.78790721696e-20\n",
      "RHO EIGENVALUE  1.2313777561e-19\n",
      "RHO EIGENVALUE  7.19949333274e-08\n",
      "RHO EIGENVALUE  7.32237828834e-08\n",
      "RHO EIGENVALUE  7.34220170028e-08\n",
      "RHO EIGENVALUE  7.53402881884e-08\n",
      "RHO EIGENVALUE  7.62970845488e-08\n",
      "RHO EIGENVALUE  4.55659160041e-07\n",
      "RHO EIGENVALUE  4.61015912248e-07\n",
      "RHO EIGENVALUE  4.64395997893e-07\n",
      "RHO EIGENVALUE  9.52524675287e-06\n",
      "RHO EIGENVALUE  3.4277913015e-05\n",
      "RHO EIGENVALUE  3.4372619371e-05\n",
      "RHO EIGENVALUE  3.44283759021e-05\n",
      "RHO EIGENVALUE  0.0391744074283\n",
      "RHO EIGENVALUE  0.0391802235469\n",
      "RHO EIGENVALUE  0.0391894261833\n",
      "RHO EIGENVALUE  0.882341587337\n",
      "Truncation error =  8.25937265986e-07\n",
      "LEFT-TO-RIGHT ITERATION  6 20 16\n",
      "Iter =  1  Ener =  -1.35984549659\n",
      "Iter =  2  Ener =  -2.7445168795\n",
      "Iter =  3  Ener =  -3.49518971253\n",
      "Iter =  4  Ener =  -3.98995355284\n",
      "Iter =  5  Ener =  -4.15550513914\n",
      "Iter =  6  Ener =  -4.20217274046\n",
      "Iter =  7  Ener =  -4.23237920879\n",
      "Iter =  8  Ener =  -4.2491875531\n",
      "Iter =  9  Ener =  -4.25544683658\n",
      "Iter =  10  Ener =  -4.2574716442\n",
      "Iter =  11  Ener =  -4.25792402629\n",
      "Iter =  12  Ener =  -4.25801666845\n",
      "Iter =  13  Ener =  -4.25802707965\n",
      "Iter =  14  Ener =  -4.25802821566\n",
      "Iter =  15  Ener =  -4.25802836135\n",
      "Iter =  16  Ener =  -4.25802838594\n",
      "E0 =  -4.25802838594\n",
      "RHO EIGENVALUE  -2.77341416304e-18\n",
      "RHO EIGENVALUE  -7.22535710041e-19\n",
      "RHO EIGENVALUE  -2.31619062046e-19\n",
      "RHO EIGENVALUE  -3.98675850189e-20\n",
      "RHO EIGENVALUE  -2.38029128796e-21\n",
      "RHO EIGENVALUE  4.45984546431e-22\n",
      "RHO EIGENVALUE  5.71363971012e-21\n",
      "RHO EIGENVALUE  2.72065519864e-19\n",
      "RHO EIGENVALUE  6.56248494294e-19\n",
      "RHO EIGENVALUE  8.1492447247e-19\n",
      "RHO EIGENVALUE  1.37059666474e-18\n",
      "RHO EIGENVALUE  1.3491381846e-17\n",
      "RHO EIGENVALUE  0.000185106052295\n",
      "RHO EIGENVALUE  0.000185604038377\n",
      "RHO EIGENVALUE  0.000186052746092\n",
      "RHO EIGENVALUE  0.000186211393898\n",
      "RHO EIGENVALUE  0.00202521150407\n",
      "RHO EIGENVALUE  0.0020266056579\n",
      "RHO EIGENVALUE  0.497578483671\n",
      "RHO EIGENVALUE  0.497626724936\n",
      "Truncation error =  -2.02041870055e-18\n",
      "RIGHT-TO-LEFT ITERATION  1 20 8\n",
      "Iter =  1  Ener =  -2.15999912683\n",
      "Iter =  2  Ener =  -3.16928010454\n",
      "Iter =  3  Ener =  -3.75772519741\n",
      "Iter =  4  Ener =  -4.01713603572\n",
      "Iter =  5  Ener =  -4.09497198981\n",
      "Iter =  6  Ener =  -4.17998820133\n",
      "Iter =  7  Ener =  -4.23752396925\n",
      "Iter =  8  Ener =  -4.25474605345\n",
      "Iter =  9  Ener =  -4.25757166281\n",
      "Iter =  10  Ener =  -4.2579624807\n",
      "Iter =  11  Ener =  -4.25801259647\n",
      "Iter =  12  Ener =  -4.25802171945\n",
      "Iter =  13  Ener =  -4.25802544158\n",
      "Iter =  14  Ener =  -4.25802787657\n",
      "Iter =  15  Ener =  -4.25802828786\n",
      "Iter =  16  Ener =  -4.25802837677\n",
      "E0 =  -4.25802837677\n",
      "RHO EIGENVALUE  0.0306347949933\n",
      "RHO EIGENVALUE  0.03063655822\n",
      "RHO EIGENVALUE  0.0306424346241\n",
      "RHO EIGENVALUE  0.908086212163\n",
      "Truncation error =  0.0\n",
      "RIGHT-TO-LEFT ITERATION  2 20 4\n",
      "Iter =  1  Ener =  -1.47842067957\n",
      "Iter =  2  Ener =  -2.55608985077\n",
      "Iter =  3  Ener =  -3.50987055826\n",
      "Iter =  4  Ener =  -3.8467591933\n",
      "Iter =  5  Ener =  -3.97909352153\n",
      "Iter =  6  Ener =  -4.03769544076\n",
      "Iter =  7  Ener =  -4.12371481391\n",
      "Iter =  8  Ener =  -4.22209041147\n",
      "Iter =  9  Ener =  -4.24904144494\n",
      "Iter =  10  Ener =  -4.2561054957\n",
      "Iter =  11  Ener =  -4.25772656018\n",
      "Iter =  12  Ener =  -4.25798438324\n",
      "Iter =  13  Ener =  -4.25802342077\n",
      "Iter =  14  Ener =  -4.25802783448\n",
      "Iter =  15  Ener =  -4.25802828861\n",
      "Iter =  16  Ener =  -4.25802835342\n",
      "E0 =  -4.25802835342\n",
      "RHO EIGENVALUE  0.000185262237588\n",
      "RHO EIGENVALUE  0.000185704467029\n",
      "RHO EIGENVALUE  0.00018617442497\n",
      "RHO EIGENVALUE  0.000186437118811\n",
      "RHO EIGENVALUE  0.00202529295544\n",
      "RHO EIGENVALUE  0.00202746362356\n",
      "RHO EIGENVALUE  0.497429132548\n",
      "RHO EIGENVALUE  0.497774532625\n",
      "Truncation error =  0.0\n",
      "RIGHT-TO-LEFT ITERATION  3 20 8\n",
      "Iter =  1  Ener =  -1.04151258221\n",
      "Iter =  2  Ener =  -2.20319248268\n",
      "Iter =  3  Ener =  -3.18836294376\n",
      "Iter =  4  Ener =  -3.73289618548\n",
      "Iter =  5  Ener =  -3.99853614233\n",
      "Iter =  6  Ener =  -4.13065155559\n",
      "Iter =  7  Ener =  -4.19884759646\n",
      "Iter =  8  Ener =  -4.22930219471\n",
      "Iter =  9  Ener =  -4.24421000961\n",
      "Iter =  10  Ener =  -4.2532151756\n",
      "Iter =  11  Ener =  -4.25697203598\n",
      "Iter =  12  Ener =  -4.25787896427\n",
      "Iter =  13  Ener =  -4.25801125772\n",
      "Iter =  14  Ener =  -4.25802887794\n",
      "Iter =  15  Ener =  -4.25803114135\n",
      "Iter =  16  Ener =  -4.25803145175\n",
      "Iter =  17  Ener =  -4.25803148417\n",
      "E0 =  -4.25803148417\n",
      "RHO EIGENVALUE  7.2360810645e-08\n",
      "RHO EIGENVALUE  7.32862989241e-08\n",
      "RHO EIGENVALUE  7.35769759567e-08\n",
      "RHO EIGENVALUE  7.41268298565e-08\n",
      "RHO EIGENVALUE  7.44509235919e-08\n",
      "RHO EIGENVALUE  4.5849036282e-07\n",
      "RHO EIGENVALUE  4.60732923005e-07\n",
      "RHO EIGENVALUE  4.61645012384e-07\n",
      "RHO EIGENVALUE  9.47851699885e-06\n",
      "RHO EIGENVALUE  3.41682990345e-05\n",
      "RHO EIGENVALUE  3.42858463929e-05\n",
      "RHO EIGENVALUE  3.43297579377e-05\n",
      "RHO EIGENVALUE  0.0391641854512\n",
      "RHO EIGENVALUE  0.0391668292235\n",
      "RHO EIGENVALUE  0.0391694663292\n",
      "RHO EIGENVALUE  0.882385507906\n",
      "Truncation error =  8.26292201794e-07\n",
      "RIGHT-TO-LEFT ITERATION  4 20 16\n",
      "Iter =  1  Ener =  -0.905191814984\n",
      "Iter =  2  Ener =  -2.26154033346\n",
      "Iter =  3  Ener =  -2.96687675985\n",
      "Iter =  4  Ener =  -3.38025653604\n",
      "Iter =  5  Ener =  -3.60518176779\n",
      "Iter =  6  Ener =  -3.77320194369\n",
      "Iter =  7  Ener =  -3.91315988575\n",
      "Iter =  8  Ener =  -4.01119360074\n",
      "Iter =  9  Ener =  -4.08302910293\n",
      "Iter =  10  Ener =  -4.14810711977\n",
      "Iter =  11  Ener =  -4.20894302106\n",
      "Iter =  12  Ener =  -4.2453530662\n",
      "Iter =  13  Ener =  -4.25554090424\n",
      "Iter =  14  Ener =  -4.25753834677\n",
      "Iter =  15  Ener =  -4.25794183526\n",
      "Iter =  16  Ener =  -4.25801469974\n",
      "Iter =  17  Ener =  -4.25802615864\n",
      "Iter =  18  Ener =  -4.25802818712\n",
      "Iter =  19  Ener =  -4.25802872337\n",
      "Iter =  20  Ener =  -4.25802885446\n",
      "Iter =  21  Ener =  -4.25802887734\n",
      "E0 =  -4.25802887734\n",
      "RHO EIGENVALUE  1.32178247256e-13\n",
      "RHO EIGENVALUE  5.23262486052e-12\n",
      "RHO EIGENVALUE  3.06733801739e-11\n",
      "RHO EIGENVALUE  4.69357198063e-11\n",
      "RHO EIGENVALUE  2.22184546558e-09\n",
      "RHO EIGENVALUE  2.38910935307e-09\n",
      "RHO EIGENVALUE  3.19047102273e-08\n",
      "RHO EIGENVALUE  3.30229064789e-08\n",
      "RHO EIGENVALUE  3.3809131892e-08\n",
      "RHO EIGENVALUE  3.66192463311e-08\n",
      "RHO EIGENVALUE  3.91865805166e-07\n",
      "RHO EIGENVALUE  4.0215762617e-07\n",
      "RHO EIGENVALUE  0.000273406285393\n",
      "RHO EIGENVALUE  0.00027381305685\n",
      "RHO EIGENVALUE  0.000274182692011\n",
      "RHO EIGENVALUE  0.000274727259078\n",
      "RHO EIGENVALUE  0.00286554647946\n",
      "RHO EIGENVALUE  0.00286680116708\n",
      "RHO EIGENVALUE  0.496564406512\n",
      "RHO EIGENVALUE  0.496606182474\n",
      "Truncation error =  1.40049923651e-07\n",
      "RIGHT-TO-LEFT ITERATION  5 20 20\n",
      "Iter =  1  Ener =  -1.06821025454\n",
      "Iter =  2  Ener =  -2.46890629367\n",
      "Iter =  3  Ener =  -3.2187439728\n",
      "Iter =  4  Ener =  -3.71041514859\n",
      "Iter =  5  Ener =  -4.02414767344\n",
      "Iter =  6  Ener =  -4.13177242308\n",
      "Iter =  7  Ener =  -4.18829994263\n",
      "Iter =  8  Ener =  -4.22393087768\n",
      "Iter =  9  Ener =  -4.24505564861\n",
      "Iter =  10  Ener =  -4.25389351924\n",
      "Iter =  11  Ener =  -4.25688553199\n",
      "Iter =  12  Ener =  -4.2578232036\n",
      "Iter =  13  Ener =  -4.25800211928\n",
      "Iter =  14  Ener =  -4.2580283105\n",
      "Iter =  15  Ener =  -4.25803116564\n",
      "Iter =  16  Ener =  -4.25803147746\n",
      "Iter =  17  Ener =  -4.25803150939\n",
      "E0 =  -4.25803150939\n",
      "RHO EIGENVALUE  -5.875209905e-20\n",
      "RHO EIGENVALUE  1.98517778245e-20\n",
      "RHO EIGENVALUE  4.34950915993e-20\n",
      "RHO EIGENVALUE  1.02428211079e-17\n",
      "RHO EIGENVALUE  7.20716259885e-08\n",
      "RHO EIGENVALUE  7.29867570409e-08\n",
      "RHO EIGENVALUE  7.34073914128e-08\n",
      "RHO EIGENVALUE  7.40636305149e-08\n",
      "RHO EIGENVALUE  7.49282549216e-08\n",
      "RHO EIGENVALUE  4.56280645661e-07\n",
      "RHO EIGENVALUE  4.58115891038e-07\n",
      "RHO EIGENVALUE  4.60245661444e-07\n",
      "RHO EIGENVALUE  9.46230614473e-06\n",
      "RHO EIGENVALUE  3.40966809093e-05\n",
      "RHO EIGENVALUE  3.41843269141e-05\n",
      "RHO EIGENVALUE  3.42468426089e-05\n",
      "RHO EIGENVALUE  0.0391517258741\n",
      "RHO EIGENVALUE  0.0391576017678\n",
      "RHO EIGENVALUE  0.0391610010978\n",
      "RHO EIGENVALUE  0.882415939004\n",
      "Truncation error =  8.2373830555e-07\n",
      "RIGHT-TO-LEFT ITERATION  6 16 20\n",
      "Iter =  1  Ener =  -1.52286175518\n",
      "Iter =  2  Ener =  -2.60858565499\n",
      "Iter =  3  Ener =  -3.22155036413\n",
      "Iter =  4  Ener =  -3.62224926035\n",
      "Iter =  5  Ener =  -3.86737390427\n",
      "Iter =  6  Ener =  -4.00241338066\n",
      "Iter =  7  Ener =  -4.1081546361\n",
      "Iter =  8  Ener =  -4.17181176155\n",
      "Iter =  9  Ener =  -4.22299858517\n",
      "Iter =  10  Ener =  -4.25246291699\n",
      "Iter =  11  Ener =  -4.25718187749\n",
      "Iter =  12  Ener =  -4.2579161884\n",
      "Iter =  13  Ener =  -4.2580127711\n",
      "Iter =  14  Ener =  -4.25802592467\n",
      "Iter =  15  Ener =  -4.25802782283\n",
      "Iter =  16  Ener =  -4.25802827264\n",
      "Iter =  17  Ener =  -4.25802837576\n",
      "Iter =  18  Ener =  -4.25802840019\n",
      "E0 =  -4.25802840019\n",
      "RHO EIGENVALUE  -1.92680538215e-18\n",
      "RHO EIGENVALUE  -1.10685588771e-18\n",
      "RHO EIGENVALUE  -1.46716887957e-19\n",
      "RHO EIGENVALUE  -1.54235630116e-20\n",
      "RHO EIGENVALUE  -1.04233113977e-20\n",
      "RHO EIGENVALUE  8.50690004309e-21\n",
      "RHO EIGENVALUE  1.45587564509e-20\n",
      "RHO EIGENVALUE  2.59352151061e-19\n",
      "RHO EIGENVALUE  1.03454844581e-18\n",
      "RHO EIGENVALUE  1.4499095042e-18\n",
      "RHO EIGENVALUE  3.08158356191e-18\n",
      "RHO EIGENVALUE  5.15421145831e-17\n",
      "RHO EIGENVALUE  0.000185252303512\n",
      "RHO EIGENVALUE  0.000185775800554\n",
      "RHO EIGENVALUE  0.000186008922294\n",
      "RHO EIGENVALUE  0.000186239452521\n",
      "RHO EIGENVALUE  0.00202477849971\n",
      "RHO EIGENVALUE  0.0020265145338\n",
      "RHO EIGENVALUE  0.49757391539\n",
      "RHO EIGENVALUE  0.497631515098\n",
      "Truncation error =  -4.39349274658e-19\n",
      "LEFT-TO-RIGHT ITERATION  1 8 20\n",
      "Iter =  1  Ener =  -2.00457682749\n",
      "Iter =  2  Ener =  -3.12449019076\n",
      "Iter =  3  Ener =  -3.47567602141\n",
      "Iter =  4  Ener =  -3.76794747205\n",
      "Iter =  5  Ener =  -3.99484506333\n",
      "Iter =  6  Ener =  -4.1052826489\n",
      "Iter =  7  Ener =  -4.17367771671\n",
      "Iter =  8  Ener =  -4.22816856915\n",
      "Iter =  9  Ener =  -4.25215835962\n",
      "Iter =  10  Ener =  -4.25717548433\n",
      "Iter =  11  Ener =  -4.25789139776\n",
      "Iter =  12  Ener =  -4.25800295738\n",
      "Iter =  13  Ener =  -4.25802110449\n",
      "Iter =  14  Ener =  -4.25802539864\n",
      "Iter =  15  Ener =  -4.25802705899\n",
      "Iter =  16  Ener =  -4.25802816522\n",
      "Iter =  17  Ener =  -4.2580283939\n",
      "Iter =  18  Ener =  -4.25802841751\n",
      "E0 =  -4.25802841751\n",
      "RHO EIGENVALUE  0.0306273009186\n",
      "RHO EIGENVALUE  0.0306282223879\n",
      "RHO EIGENVALUE  0.0306294072801\n",
      "RHO EIGENVALUE  0.908115069413\n",
      "Truncation error =  0.0\n",
      "LEFT-TO-RIGHT ITERATION  2 4 20\n",
      "Iter =  1  Ener =  -1.41321021538\n",
      "Iter =  2  Ener =  -2.60001581997\n",
      "Iter =  3  Ener =  -3.46717097984\n",
      "Iter =  4  Ener =  -3.93114004521\n",
      "Iter =  5  Ener =  -4.15264679203\n",
      "Iter =  6  Ener =  -4.21788499428\n",
      "Iter =  7  Ener =  -4.24159242444\n",
      "Iter =  8  Ener =  -4.25066345225\n",
      "Iter =  9  Ener =  -4.25500097349\n",
      "Iter =  10  Ener =  -4.25734802008\n",
      "Iter =  11  Ener =  -4.25790758924\n",
      "Iter =  12  Ener =  -4.25801381266\n",
      "Iter =  13  Ener =  -4.25802592312\n",
      "Iter =  14  Ener =  -4.25802790163\n",
      "Iter =  15  Ener =  -4.25802832163\n",
      "Iter =  16  Ener =  -4.25802841248\n",
      "E0 =  -4.25802841248\n",
      "RHO EIGENVALUE  0.000184915824839\n",
      "RHO EIGENVALUE  0.00018569447858\n",
      "RHO EIGENVALUE  0.000185920136462\n",
      "RHO EIGENVALUE  0.000186223586615\n",
      "RHO EIGENVALUE  0.00202437254469\n",
      "RHO EIGENVALUE  0.00202524264902\n",
      "RHO EIGENVALUE  0.497585515972\n",
      "RHO EIGENVALUE  0.497622114808\n",
      "Truncation error =  0.0\n",
      "LEFT-TO-RIGHT ITERATION  3 8 20\n",
      "Iter =  1  Ener =  -1.08577063528\n",
      "Iter =  2  Ener =  -2.28395384239\n",
      "Iter =  3  Ener =  -3.24963074707\n",
      "Iter =  4  Ener =  -3.66239812105\n",
      "Iter =  5  Ener =  -3.83198568672\n",
      "Iter =  6  Ener =  -3.88937775688\n",
      "Iter =  7  Ener =  -3.91432473388\n",
      "Iter =  8  Ener =  -3.92551361742\n",
      "Iter =  9  Ener =  -3.92930823658\n",
      "Iter =  10  Ener =  -3.93152550539\n",
      "Iter =  11  Ener =  -3.93998072655\n",
      "Iter =  12  Ener =  -4.16073335678\n",
      "Iter =  13  Ener =  -4.23735543562\n",
      "Iter =  14  Ener =  -4.25412397476\n",
      "Iter =  15  Ener =  -4.25724069498\n",
      "Iter =  16  Ener =  -4.25787425965\n",
      "Iter =  17  Ener =  -4.25800198003\n",
      "Iter =  18  Ener =  -4.25802798921\n",
      "Iter =  19  Ener =  -4.25803110135\n",
      "Iter =  20  Ener =  -4.25803145308\n",
      "Iter =  21  Ener =  -4.25803150063\n",
      "E0 =  -4.25803150063\n",
      "RHO EIGENVALUE  7.11005077648e-08\n",
      "RHO EIGENVALUE  7.20954857632e-08\n",
      "RHO EIGENVALUE  7.312271879e-08\n",
      "RHO EIGENVALUE  7.5006414495e-08\n",
      "RHO EIGENVALUE  7.55312003718e-08\n",
      "RHO EIGENVALUE  4.55574151712e-07\n",
      "RHO EIGENVALUE  4.60206978314e-07\n",
      "RHO EIGENVALUE  4.62163159278e-07\n",
      "RHO EIGENVALUE  9.46636925546e-06\n",
      "RHO EIGENVALUE  3.41741494692e-05\n",
      "RHO EIGENVALUE  3.42371566561e-05\n",
      "RHO EIGENVALUE  3.43023798054e-05\n",
      "RHO EIGENVALUE  0.0391494570644\n",
      "RHO EIGENVALUE  0.03916623482\n",
      "RHO EIGENVALUE  0.039183804589\n",
      "RHO EIGENVALUE  0.882386578671\n",
      "Truncation error =  8.22430478897e-07\n",
      "LEFT-TO-RIGHT ITERATION  4 16 20\n",
      "Iter =  1  Ener =  -0.837398680376\n",
      "Iter =  2  Ener =  -2.30941198482\n",
      "Iter =  3  Ener =  -3.12551403822\n",
      "Iter =  4  Ener =  -3.49154732985\n",
      "Iter =  5  Ener =  -3.76417199178\n",
      "Iter =  6  Ener =  -4.03864499711\n",
      "Iter =  7  Ener =  -4.17009785537\n",
      "Iter =  8  Ener =  -4.21736020061\n",
      "Iter =  9  Ener =  -4.23666778299\n",
      "Iter =  10  Ener =  -4.24724014488\n",
      "Iter =  11  Ener =  -4.254010507\n",
      "Iter =  12  Ener =  -4.25684154568\n",
      "Iter =  13  Ener =  -4.25771244472\n",
      "Iter =  14  Ener =  -4.25795089656\n",
      "Iter =  15  Ener =  -4.25801096818\n",
      "Iter =  16  Ener =  -4.25802454399\n",
      "Iter =  17  Ener =  -4.25802808861\n",
      "Iter =  18  Ener =  -4.25802877699\n",
      "Iter =  19  Ener =  -4.25802889523\n",
      "Iter =  20  Ener =  -4.25802891472\n",
      "E0 =  -4.25802891472\n",
      "RHO EIGENVALUE  5.41882777091e-12\n",
      "RHO EIGENVALUE  2.98174025781e-11\n",
      "RHO EIGENVALUE  3.909749842e-11\n",
      "RHO EIGENVALUE  8.06832231754e-11\n",
      "RHO EIGENVALUE  2.3642343716e-09\n",
      "RHO EIGENVALUE  2.65157957024e-09\n",
      "RHO EIGENVALUE  3.10490894714e-08\n",
      "RHO EIGENVALUE  3.24569062553e-08\n",
      "RHO EIGENVALUE  3.53780999978e-08\n",
      "RHO EIGENVALUE  3.68056866806e-08\n",
      "RHO EIGENVALUE  3.96383722345e-07\n",
      "RHO EIGENVALUE  3.98730137364e-07\n",
      "RHO EIGENVALUE  0.000273279880867\n",
      "RHO EIGENVALUE  0.000273538964662\n",
      "RHO EIGENVALUE  0.000274364539009\n",
      "RHO EIGENVALUE  0.00027465781333\n",
      "RHO EIGENVALUE  0.00286515235288\n",
      "RHO EIGENVALUE  0.00286589150716\n",
      "RHO EIGENVALUE  0.496551922663\n",
      "RHO EIGENVALUE  0.496620256304\n",
      "Truncation error =  1.40860613299e-07\n",
      "LEFT-TO-RIGHT ITERATION  5 20 20\n",
      "Iter =  1  Ener =  -1.11335008815\n",
      "Iter =  2  Ener =  -2.52548996174\n",
      "Iter =  3  Ener =  -3.39208214799\n",
      "Iter =  4  Ener =  -3.88735494341\n",
      "Iter =  5  Ener =  -4.09812035337\n",
      "Iter =  6  Ener =  -4.16438409539\n",
      "Iter =  7  Ener =  -4.20531591446\n",
      "Iter =  8  Ener =  -4.23791718307\n",
      "Iter =  9  Ener =  -4.25188339417\n",
      "Iter =  10  Ener =  -4.25624579568\n",
      "Iter =  11  Ener =  -4.25758162222\n",
      "Iter =  12  Ener =  -4.25794655022\n",
      "Iter =  13  Ener =  -4.25802025434\n",
      "Iter =  14  Ener =  -4.25802991662\n",
      "Iter =  15  Ener =  -4.25803132803\n",
      "Iter =  16  Ener =  -4.25803149893\n",
      "Iter =  17  Ener =  -4.25803151677\n",
      "E0 =  -4.25803151677\n",
      "RHO EIGENVALUE  -1.60996381537e-17\n",
      "RHO EIGENVALUE  -1.04815668578e-19\n",
      "RHO EIGENVALUE  -3.4887053664e-21\n",
      "RHO EIGENVALUE  4.94250655605e-20\n",
      "RHO EIGENVALUE  7.23121723311e-08\n",
      "RHO EIGENVALUE  7.26288263217e-08\n",
      "RHO EIGENVALUE  7.30533221119e-08\n",
      "RHO EIGENVALUE  7.3487999904e-08\n",
      "RHO EIGENVALUE  7.42702951773e-08\n",
      "RHO EIGENVALUE  4.55681286375e-07\n",
      "RHO EIGENVALUE  4.5794660061e-07\n",
      "RHO EIGENVALUE  4.62037677013e-07\n",
      "RHO EIGENVALUE  9.46527752122e-06\n",
      "RHO EIGENVALUE  3.41787031597e-05\n",
      "RHO EIGENVALUE  3.42257612889e-05\n",
      "RHO EIGENVALUE  3.43145684558e-05\n",
      "RHO EIGENVALUE  0.0391592389891\n",
      "RHO EIGENVALUE  0.0391662006025\n",
      "RHO EIGENVALUE  0.0391715109291\n",
      "RHO EIGENVALUE  0.882389123751\n",
      "Truncation error =  8.21433902205e-07\n",
      "LEFT-TO-RIGHT ITERATION  6 20 16\n",
      "Iter =  1  Ener =  -1.31301139087\n",
      "Iter =  2  Ener =  -2.38706072628\n",
      "Iter =  3  Ener =  -3.09371565083\n",
      "Iter =  4  Ener =  -3.57237849915\n",
      "Iter =  5  Ener =  -3.91487966346\n",
      "Iter =  6  Ener =  -4.04835365268\n",
      "Iter =  7  Ener =  -4.12736273099\n",
      "Iter =  8  Ener =  -4.19368273742\n",
      "Iter =  9  Ener =  -4.23444090939\n",
      "Iter =  10  Ener =  -4.25280437688\n",
      "Iter =  11  Ener =  -4.25712146947\n",
      "Iter =  12  Ener =  -4.25787421462\n",
      "Iter =  13  Ener =  -4.25800746215\n",
      "Iter =  14  Ener =  -4.25802387702\n",
      "Iter =  15  Ener =  -4.25802734152\n",
      "Iter =  16  Ener =  -4.25802822179\n",
      "Iter =  17  Ener =  -4.25802836059\n",
      "Iter =  18  Ener =  -4.25802839553\n",
      "E0 =  -4.25802839553\n",
      "RHO EIGENVALUE  -1.06434146155e-16\n",
      "RHO EIGENVALUE  -8.51028090086e-18\n",
      "RHO EIGENVALUE  -5.35413039202e-18\n",
      "RHO EIGENVALUE  -8.27632275985e-19\n",
      "RHO EIGENVALUE  -2.46165118506e-20\n",
      "RHO EIGENVALUE  -1.97616702308e-20\n",
      "RHO EIGENVALUE  -4.76411206283e-21\n",
      "RHO EIGENVALUE  1.00813422798e-20\n",
      "RHO EIGENVALUE  7.87615049429e-20\n",
      "RHO EIGENVALUE  1.36038095214e-18\n",
      "RHO EIGENVALUE  2.81163983779e-18\n",
      "RHO EIGENVALUE  6.09865789638e-18\n",
      "RHO EIGENVALUE  0.000185146362108\n",
      "RHO EIGENVALUE  0.000185843838207\n",
      "RHO EIGENVALUE  0.000186167651483\n",
      "RHO EIGENVALUE  0.000186301221144\n",
      "RHO EIGENVALUE  0.00202465451191\n",
      "RHO EIGENVALUE  0.00202717969115\n",
      "RHO EIGENVALUE  0.497593074503\n",
      "RHO EIGENVALUE  0.497611632221\n",
      "Truncation error =  -1.19726108218e-16\n",
      "RIGHT-TO-LEFT ITERATION  1 20 8\n",
      "Iter =  1  Ener =  -1.9744540405\n",
      "Iter =  2  Ener =  -3.15277682293\n",
      "Iter =  3  Ener =  -3.67628061154\n",
      "Iter =  4  Ener =  -3.87644765493\n",
      "Iter =  5  Ener =  -3.93978825504\n",
      "Iter =  6  Ener =  -3.99177912951\n",
      "Iter =  7  Ener =  -4.12679120342\n",
      "Iter =  8  Ener =  -4.2316712114\n",
      "Iter =  9  Ener =  -4.25506901332\n",
      "Iter =  10  Ener =  -4.25769901712\n",
      "Iter =  11  Ener =  -4.25796942847\n",
      "Iter =  12  Ener =  -4.25802096821\n",
      "Iter =  13  Ener =  -4.258026616\n",
      "Iter =  14  Ener =  -4.25802786049\n",
      "Iter =  15  Ener =  -4.25802812559\n",
      "Iter =  16  Ener =  -4.25802834359\n",
      "Iter =  17  Ener =  -4.25802842186\n",
      "E0 =  -4.25802842186\n",
      "RHO EIGENVALUE  0.0306279337751\n",
      "RHO EIGENVALUE  0.0306324050931\n",
      "RHO EIGENVALUE  0.0306352401624\n",
      "RHO EIGENVALUE  0.908104420969\n",
      "Truncation error =  0.0\n",
      "RIGHT-TO-LEFT ITERATION  2 20 4\n",
      "Iter =  1  Ener =  -1.47359506737\n",
      "Iter =  2  Ener =  -2.48653027944\n",
      "Iter =  3  Ener =  -3.13558671057\n",
      "Iter =  4  Ener =  -3.64076218564\n",
      "Iter =  5  Ener =  -4.01551353173\n",
      "Iter =  6  Ener =  -4.1831272418\n",
      "Iter =  7  Ener =  -4.23980269313\n",
      "Iter =  8  Ener =  -4.2522915063\n",
      "Iter =  9  Ener =  -4.25518516822\n",
      "Iter =  10  Ener =  -4.25676911609\n",
      "Iter =  11  Ener =  -4.25772013694\n",
      "Iter =  12  Ener =  -4.25798563998\n",
      "Iter =  13  Ener =  -4.25802420107\n",
      "Iter =  14  Ener =  -4.25802798597\n",
      "Iter =  15  Ener =  -4.2580283696\n",
      "Iter =  16  Ener =  -4.25802841821\n",
      "E0 =  -4.25802841821\n",
      "RHO EIGENVALUE  0.00018536224484\n",
      "RHO EIGENVALUE  0.000185927083226\n",
      "RHO EIGENVALUE  0.000186273450392\n",
      "RHO EIGENVALUE  0.000186488873238\n",
      "RHO EIGENVALUE  0.00202714121345\n",
      "RHO EIGENVALUE  0.00202948125454\n",
      "RHO EIGENVALUE  0.497555774789\n",
      "RHO EIGENVALUE  0.497643551091\n",
      "Truncation error =  0.0\n",
      "RIGHT-TO-LEFT ITERATION  3 20 8\n",
      "Iter =  1  Ener =  -1.02882581966\n",
      "Iter =  2  Ener =  -2.44001914288\n",
      "Iter =  3  Ener =  -3.34223109132\n",
      "Iter =  4  Ener =  -3.7279050039\n",
      "Iter =  5  Ener =  -3.87106341408\n",
      "Iter =  6  Ener =  -3.91839494473\n",
      "Iter =  7  Ener =  -3.94218846095\n",
      "Iter =  8  Ener =  -3.97222288242\n",
      "Iter =  9  Ener =  -4.05886009963\n",
      "Iter =  10  Ener =  -4.18622351936\n",
      "Iter =  11  Ener =  -4.24160716744\n",
      "Iter =  12  Ener =  -4.25571647134\n",
      "Iter =  13  Ener =  -4.25767515963\n",
      "Iter =  14  Ener =  -4.25798370417\n",
      "Iter =  15  Ener =  -4.258024214\n",
      "Iter =  16  Ener =  -4.25803027177\n",
      "Iter =  17  Ener =  -4.25803121915\n",
      "Iter =  18  Ener =  -4.25803146564\n",
      "Iter =  19  Ener =  -4.25803150822\n",
      "E0 =  -4.25803150822\n",
      "RHO EIGENVALUE  7.12262732026e-08\n",
      "RHO EIGENVALUE  7.25474720111e-08\n",
      "RHO EIGENVALUE  7.32804758042e-08\n",
      "RHO EIGENVALUE  7.38048953813e-08\n",
      "RHO EIGENVALUE  7.44415553592e-08\n",
      "RHO EIGENVALUE  4.54102360498e-07\n",
      "RHO EIGENVALUE  4.56457894615e-07\n",
      "RHO EIGENVALUE  4.6203181751e-07\n",
      "RHO EIGENVALUE  9.47244906077e-06\n",
      "RHO EIGENVALUE  3.41278405685e-05\n",
      "RHO EIGENVALUE  3.41921770096e-05\n",
      "RHO EIGENVALUE  3.43130212953e-05\n",
      "RHO EIGENVALUE  0.0391533729189\n",
      "RHO EIGENVALUE  0.0391596315411\n",
      "RHO EIGENVALUE  0.0391652013573\n",
      "RHO EIGENVALUE  0.882407950802\n",
      "Truncation error =  8.19403032257e-07\n",
      "RIGHT-TO-LEFT ITERATION  4 20 16\n",
      "Iter =  1  Ener =  -0.839099353483\n",
      "Iter =  2  Ener =  -2.09253377816\n",
      "Iter =  3  Ener =  -2.82795225931\n",
      "Iter =  4  Ener =  -3.30842200076\n",
      "Iter =  5  Ener =  -3.55511148851\n",
      "Iter =  6  Ener =  -3.73200893457\n",
      "Iter =  7  Ener =  -3.85012053712\n",
      "Iter =  8  Ener =  -3.93008320076\n",
      "Iter =  9  Ener =  -3.99137289765\n",
      "Iter =  10  Ener =  -4.04504567593\n",
      "Iter =  11  Ener =  -4.13239282355\n",
      "Iter =  12  Ener =  -4.2206065179\n",
      "Iter =  13  Ener =  -4.25022384791\n",
      "Iter =  14  Ener =  -4.25634597264\n",
      "Iter =  15  Ener =  -4.25764898772\n",
      "Iter =  16  Ener =  -4.25794465906\n",
      "Iter =  17  Ener =  -4.25801108123\n",
      "Iter =  18  Ener =  -4.25802482816\n",
      "Iter =  19  Ener =  -4.2580280439\n",
      "Iter =  20  Ener =  -4.25802878496\n",
      "Iter =  21  Ener =  -4.25802889148\n",
      "Iter =  22  Ener =  -4.25802890938\n",
      "E0 =  -4.25802890938\n",
      "RHO EIGENVALUE  7.09773601125e-12\n",
      "RHO EIGENVALUE  2.88767349823e-11\n",
      "RHO EIGENVALUE  3.94931077885e-11\n",
      "RHO EIGENVALUE  7.74658698276e-11\n",
      "RHO EIGENVALUE  2.44052726412e-09\n",
      "RHO EIGENVALUE  2.65934775213e-09\n",
      "RHO EIGENVALUE  3.16189568932e-08\n",
      "RHO EIGENVALUE  3.20965589183e-08\n",
      "RHO EIGENVALUE  3.45736486198e-08\n",
      "RHO EIGENVALUE  3.59722270181e-08\n",
      "RHO EIGENVALUE  3.91936306286e-07\n",
      "RHO EIGENVALUE  4.03178567836e-07\n",
      "RHO EIGENVALUE  0.000273369534642\n",
      "RHO EIGENVALUE  0.000273669958104\n",
      "RHO EIGENVALUE  0.00027418193634\n",
      "RHO EIGENVALUE  0.00027474271554\n",
      "RHO EIGENVALUE  0.00286480724065\n",
      "RHO EIGENVALUE  0.00286637498964\n",
      "RHO EIGENVALUE  0.496490803347\n",
      "RHO EIGENVALUE  0.496681115649\n",
      "Truncation error =  1.39514199914e-07\n",
      "RIGHT-TO-LEFT ITERATION  5 20 20\n",
      "Iter =  1  Ener =  -1.031056239\n",
      "Iter =  2  Ener =  -2.25914741375\n",
      "Iter =  3  Ener =  -3.1381352287\n",
      "Iter =  4  Ener =  -3.70882944358\n",
      "Iter =  5  Ener =  -4.04848877\n",
      "Iter =  6  Ener =  -4.16899889699\n",
      "Iter =  7  Ener =  -4.213503067\n",
      "Iter =  8  Ener =  -4.2378706116\n",
      "Iter =  9  Ener =  -4.24919791537\n",
      "Iter =  10  Ener =  -4.25444604321\n",
      "Iter =  11  Ener =  -4.25716670471\n",
      "Iter =  12  Ener =  -4.25785581971\n",
      "Iter =  13  Ener =  -4.2580082739\n",
      "Iter =  14  Ener =  -4.25802862199\n",
      "Iter =  15  Ener =  -4.25803110137\n",
      "Iter =  16  Ener =  -4.25803146023\n",
      "Iter =  17  Ener =  -4.25803150573\n",
      "E0 =  -4.25803150573\n",
      "RHO EIGENVALUE  -1.28547807583e-18\n",
      "RHO EIGENVALUE  -7.3990645448e-20\n",
      "RHO EIGENVALUE  1.50750893355e-21\n",
      "RHO EIGENVALUE  6.28540989703e-20\n",
      "RHO EIGENVALUE  7.21584479333e-08\n",
      "RHO EIGENVALUE  7.30413458232e-08\n",
      "RHO EIGENVALUE  7.37906038265e-08\n",
      "RHO EIGENVALUE  7.42025876769e-08\n",
      "RHO EIGENVALUE  7.47119096631e-08\n",
      "RHO EIGENVALUE  4.58013024318e-07\n",
      "RHO EIGENVALUE  4.59719967302e-07\n",
      "RHO EIGENVALUE  4.63752071956e-07\n",
      "RHO EIGENVALUE  9.44319438388e-06\n",
      "RHO EIGENVALUE  3.41251298425e-05\n",
      "RHO EIGENVALUE  3.41425283285e-05\n",
      "RHO EIGENVALUE  3.41952836468e-05\n",
      "RHO EIGENVALUE  0.0391521349857\n",
      "RHO EIGENVALUE  0.0391535274123\n",
      "RHO EIGENVALUE  0.0391557316311\n",
      "RHO EIGENVALUE  0.882424950445\n",
      "Truncation error =  8.25917919239e-07\n",
      "RIGHT-TO-LEFT ITERATION  6 16 20\n",
      "Iter =  1  Ener =  -1.37005586617\n",
      "Iter =  2  Ener =  -2.79561298118\n",
      "Iter =  3  Ener =  -3.52866486656\n",
      "Iter =  4  Ener =  -3.8120915378\n",
      "Iter =  5  Ener =  -3.89722631093\n",
      "Iter =  6  Ener =  -3.92936101885\n",
      "Iter =  7  Ener =  -3.95153690617\n",
      "Iter =  8  Ener =  -4.0121574726\n",
      "Iter =  9  Ener =  -4.1654874205\n",
      "Iter =  10  Ener =  -4.23951708037\n",
      "Iter =  11  Ener =  -4.25522431782\n",
      "Iter =  12  Ener =  -4.25768355383\n",
      "Iter =  13  Ener =  -4.2579802573\n",
      "Iter =  14  Ener =  -4.25801828471\n",
      "Iter =  15  Ener =  -4.25802641435\n",
      "Iter =  16  Ener =  -4.25802800618\n",
      "Iter =  17  Ener =  -4.25802829903\n",
      "Iter =  18  Ener =  -4.25802836375\n",
      "E0 =  -4.25802836375\n",
      "RHO EIGENVALUE  -1.41304905932e-17\n",
      "RHO EIGENVALUE  -5.45673956566e-18\n",
      "RHO EIGENVALUE  -1.19213746513e-18\n",
      "RHO EIGENVALUE  -7.98608788411e-20\n",
      "RHO EIGENVALUE  -3.27121207314e-20\n",
      "RHO EIGENVALUE  -3.91163113569e-21\n",
      "RHO EIGENVALUE  1.4532231866e-20\n",
      "RHO EIGENVALUE  5.59894754645e-20\n",
      "RHO EIGENVALUE  1.75876775475e-19\n",
      "RHO EIGENVALUE  3.35509440265e-19\n",
      "RHO EIGENVALUE  1.74677823228e-18\n",
      "RHO EIGENVALUE  4.49095529722e-18\n",
      "RHO EIGENVALUE  0.000185277373136\n",
      "RHO EIGENVALUE  0.00018566887471\n",
      "RHO EIGENVALUE  0.000186041741695\n",
      "RHO EIGENVALUE  0.000186394735853\n",
      "RHO EIGENVALUE  0.00202584242904\n",
      "RHO EIGENVALUE  0.00202763616998\n",
      "RHO EIGENVALUE  0.497343424634\n",
      "RHO EIGENVALUE  0.497859714041\n",
      "Truncation error =  -2.03139443316e-17\n",
      "LEFT-TO-RIGHT ITERATION  1 8 20\n",
      "Iter =  1  Ener =  -2.00618189469\n",
      "Iter =  2  Ener =  -3.19418041263\n",
      "Iter =  3  Ener =  -3.7774094422\n",
      "Iter =  4  Ener =  -3.91441329211\n",
      "Iter =  5  Ener =  -3.96121160603\n",
      "Iter =  6  Ener =  -4.04494248317\n",
      "Iter =  7  Ener =  -4.18365081609\n",
      "Iter =  8  Ener =  -4.24375117246\n",
      "Iter =  9  Ener =  -4.25628594012\n",
      "Iter =  10  Ener =  -4.2578813143\n",
      "Iter =  11  Ener =  -4.25800759874\n",
      "Iter =  12  Ener =  -4.25802010879\n",
      "Iter =  13  Ener =  -4.25802444962\n",
      "Iter =  14  Ener =  -4.25802732362\n",
      "Iter =  15  Ener =  -4.25802827997\n",
      "Iter =  16  Ener =  -4.2580283928\n",
      "Iter =  17  Ener =  -4.25802841064\n",
      "E0 =  -4.25802841064\n",
      "RHO EIGENVALUE  0.0306237515295\n",
      "RHO EIGENVALUE  0.0306299774523\n",
      "RHO EIGENVALUE  0.0306334628211\n",
      "RHO EIGENVALUE  0.908112808197\n",
      "Truncation error =  0.0\n",
      "LEFT-TO-RIGHT ITERATION  2 4 20\n",
      "Iter =  1  Ener =  -1.40402890442\n",
      "Iter =  2  Ener =  -2.60537142062\n",
      "Iter =  3  Ener =  -3.45781247357\n",
      "Iter =  4  Ener =  -4.03943716789\n",
      "Iter =  5  Ener =  -4.18181020279\n",
      "Iter =  6  Ener =  -4.21785320924\n",
      "Iter =  7  Ener =  -4.2403589101\n",
      "Iter =  8  Ener =  -4.25159981855\n",
      "Iter =  9  Ener =  -4.2558127083\n",
      "Iter =  10  Ener =  -4.25759096185\n",
      "Iter =  11  Ener =  -4.25796922893\n",
      "Iter =  12  Ener =  -4.25801862439\n",
      "Iter =  13  Ener =  -4.25802733722\n",
      "Iter =  14  Ener =  -4.25802828634\n",
      "Iter =  15  Ener =  -4.25802839716\n",
      "Iter =  16  Ener =  -4.2580284152\n",
      "E0 =  -4.2580284152\n",
      "RHO EIGENVALUE  0.000185101717126\n",
      "RHO EIGENVALUE  0.000185722122505\n",
      "RHO EIGENVALUE  0.000186056036936\n",
      "RHO EIGENVALUE  0.000186175690077\n",
      "RHO EIGENVALUE  0.00202555427282\n",
      "RHO EIGENVALUE  0.00202625461604\n",
      "RHO EIGENVALUE  0.497555921032\n",
      "RHO EIGENVALUE  0.497649214512\n",
      "Truncation error =  0.0\n",
      "LEFT-TO-RIGHT ITERATION  3 8 20\n",
      "Iter =  1  Ener =  -0.964761293464\n",
      "Iter =  2  Ener =  -2.53979110281\n",
      "Iter =  3  Ener =  -3.54845305938\n",
      "Iter =  4  Ener =  -3.89942971478\n",
      "Iter =  5  Ener =  -3.99797090788\n",
      "Iter =  6  Ener =  -4.05326239127\n",
      "Iter =  7  Ener =  -4.12687653753\n",
      "Iter =  8  Ener =  -4.22170389132\n",
      "Iter =  9  Ener =  -4.25202088679\n",
      "Iter =  10  Ener =  -4.25675157727\n",
      "Iter =  11  Ener =  -4.25769741209\n",
      "Iter =  12  Ener =  -4.25795102645\n",
      "Iter =  13  Ener =  -4.25801797026\n",
      "Iter =  14  Ener =  -4.25802948378\n",
      "Iter =  15  Ener =  -4.25803122464\n",
      "Iter =  16  Ener =  -4.25803147984\n",
      "Iter =  17  Ener =  -4.25803151016\n",
      "E0 =  -4.25803151016\n",
      "RHO EIGENVALUE  7.1492581995e-08\n",
      "RHO EIGENVALUE  7.28160390856e-08\n",
      "RHO EIGENVALUE  7.31449723262e-08\n",
      "RHO EIGENVALUE  7.43334287158e-08\n",
      "RHO EIGENVALUE  7.46649272354e-08\n",
      "RHO EIGENVALUE  4.58211362112e-07\n",
      "RHO EIGENVALUE  4.60312719031e-07\n",
      "RHO EIGENVALUE  4.6230011148e-07\n",
      "RHO EIGENVALUE  9.4584625639e-06\n",
      "RHO EIGENVALUE  3.41461632237e-05\n",
      "RHO EIGENVALUE  3.42163032327e-05\n",
      "RHO EIGENVALUE  3.42601070622e-05\n",
      "RHO EIGENVALUE  0.0391562369122\n",
      "RHO EIGENVALUE  0.0391594098405\n",
      "RHO EIGENVALUE  0.039163717762\n",
      "RHO EIGENVALUE  0.882406807173\n",
      "Truncation error =  8.2466331147e-07\n",
      "LEFT-TO-RIGHT ITERATION  4 16 20\n",
      "Iter =  1  Ener =  -0.768300770095\n",
      "Iter =  2  Ener =  -1.95650111719\n",
      "Iter =  3  Ener =  -2.71890281972\n",
      "Iter =  4  Ener =  -3.18760664398\n",
      "Iter =  5  Ener =  -3.55838184148\n",
      "Iter =  6  Ener =  -3.80384995075\n",
      "Iter =  7  Ener =  -3.92264791888\n",
      "Iter =  8  Ener =  -3.99029027831\n",
      "Iter =  9  Ener =  -4.05163596569\n",
      "Iter =  10  Ener =  -4.1339213832\n",
      "Iter =  11  Ener =  -4.20574297449\n",
      "Iter =  12  Ener =  -4.24156653113\n",
      "Iter =  13  Ener =  -4.25381965597\n",
      "Iter =  14  Ener =  -4.25721035799\n",
      "Iter =  15  Ener =  -4.25789550787\n",
      "Iter =  16  Ener =  -4.2580088339\n",
      "Iter =  17  Ener =  -4.25802633547\n",
      "Iter =  18  Ener =  -4.25802850565\n",
      "Iter =  19  Ener =  -4.25802881932\n",
      "Iter =  20  Ener =  -4.25802888909\n",
      "E0 =  -4.25802888909\n",
      "RHO EIGENVALUE  3.51287282632e-12\n",
      "RHO EIGENVALUE  3.73869316451e-11\n",
      "RHO EIGENVALUE  6.54486013065e-11\n",
      "RHO EIGENVALUE  8.57154439456e-11\n",
      "RHO EIGENVALUE  2.4223997821e-09\n",
      "RHO EIGENVALUE  2.68252554776e-09\n",
      "RHO EIGENVALUE  3.22320014356e-08\n",
      "RHO EIGENVALUE  3.34425968786e-08\n",
      "RHO EIGENVALUE  3.45959812191e-08\n",
      "RHO EIGENVALUE  3.60331038995e-08\n",
      "RHO EIGENVALUE  3.95756587962e-07\n",
      "RHO EIGENVALUE  3.97463973494e-07\n",
      "RHO EIGENVALUE  0.00027356616924\n",
      "RHO EIGENVALUE  0.000274338623052\n",
      "RHO EIGENVALUE  0.000274581379416\n",
      "RHO EIGENVALUE  0.000274964875835\n",
      "RHO EIGENVALUE  0.00286767363079\n",
      "RHO EIGENVALUE  0.00287019437698\n",
      "RHO EIGENVALUE  0.49652561338\n",
      "RHO EIGENVALUE  0.496638132743\n",
      "Truncation error =  1.41600672612e-07\n",
      "LEFT-TO-RIGHT ITERATION  5 20 20\n",
      "Iter =  1  Ener =  -0.975142351742\n",
      "Iter =  2  Ener =  -2.19757032748\n",
      "Iter =  3  Ener =  -3.02679450394\n",
      "Iter =  4  Ener =  -3.57418605534\n",
      "Iter =  5  Ener =  -3.90685092317\n",
      "Iter =  6  Ener =  -4.09003999485\n",
      "Iter =  7  Ener =  -4.17649623135\n",
      "Iter =  8  Ener =  -4.21621208293\n",
      "Iter =  9  Ener =  -4.23864828011\n",
      "Iter =  10  Ener =  -4.25058079853\n",
      "Iter =  11  Ener =  -4.25588550525\n",
      "Iter =  12  Ener =  -4.25767191491\n",
      "Iter =  13  Ener =  -4.25797449841\n",
      "Iter =  14  Ener =  -4.25802115321\n",
      "Iter =  15  Ener =  -4.25802910879\n",
      "Iter =  16  Ener =  -4.25803103167\n",
      "Iter =  17  Ener =  -4.25803143644\n",
      "Iter =  18  Ener =  -4.25803150601\n",
      "E0 =  -4.25803150601\n",
      "RHO EIGENVALUE  -2.04503295963e-18\n",
      "RHO EIGENVALUE  -1.16610362815e-19\n",
      "RHO EIGENVALUE  1.33100584256e-19\n",
      "RHO EIGENVALUE  2.98367330028e-19\n",
      "RHO EIGENVALUE  7.08646108021e-08\n",
      "RHO EIGENVALUE  7.20000192684e-08\n",
      "RHO EIGENVALUE  7.31423361469e-08\n",
      "RHO EIGENVALUE  7.44600873639e-08\n",
      "RHO EIGENVALUE  7.53947769172e-08\n",
      "RHO EIGENVALUE  4.53550487245e-07\n",
      "RHO EIGENVALUE  4.5993746323e-07\n",
      "RHO EIGENVALUE  4.63525486768e-07\n",
      "RHO EIGENVALUE  9.47997510504e-06\n",
      "RHO EIGENVALUE  3.41110134332e-05\n",
      "RHO EIGENVALUE  3.41647650365e-05\n",
      "RHO EIGENVALUE  3.43112778067e-05\n",
      "RHO EIGENVALUE  0.0391558779965\n",
      "RHO EIGENVALUE  0.0391641070163\n",
      "RHO EIGENVALUE  0.0391698857\n",
      "RHO EIGENVALUE  0.88239631938\n",
      "Truncation error =  8.19412317742e-07\n",
      "LEFT-TO-RIGHT ITERATION  6 20 16\n",
      "Iter =  1  Ener =  -1.46249446755\n",
      "Iter =  2  Ener =  -2.55264913785\n",
      "Iter =  3  Ener =  -3.41994571188\n",
      "Iter =  4  Ener =  -3.84209545045\n",
      "Iter =  5  Ener =  -4.06226404346\n",
      "Iter =  6  Ener =  -4.15681276239\n",
      "Iter =  7  Ener =  -4.20508813937\n",
      "Iter =  8  Ener =  -4.23626003491\n",
      "Iter =  9  Ener =  -4.25143950109\n",
      "Iter =  10  Ener =  -4.25703249664\n",
      "Iter =  11  Ener =  -4.25786934481\n",
      "Iter =  12  Ener =  -4.25799960725\n",
      "Iter =  13  Ener =  -4.2580223564\n",
      "Iter =  14  Ener =  -4.25802710424\n",
      "Iter =  15  Ener =  -4.2580282066\n",
      "Iter =  16  Ener =  -4.25802838606\n",
      "Iter =  17  Ener =  -4.25802841124\n",
      "E0 =  -4.25802841124\n",
      "RHO EIGENVALUE  -6.10538506859e-17\n",
      "RHO EIGENVALUE  -3.97994038289e-18\n",
      "RHO EIGENVALUE  -1.37342340947e-18\n",
      "RHO EIGENVALUE  -2.2483147354e-19\n",
      "RHO EIGENVALUE  -5.53879001066e-20\n",
      "RHO EIGENVALUE  -1.13738770328e-20\n",
      "RHO EIGENVALUE  -4.46495372454e-21\n",
      "RHO EIGENVALUE  -7.67057428103e-22\n",
      "RHO EIGENVALUE  5.1534808019e-20\n",
      "RHO EIGENVALUE  2.71113200387e-19\n",
      "RHO EIGENVALUE  6.59457596793e-19\n",
      "RHO EIGENVALUE  1.28777159474e-18\n",
      "RHO EIGENVALUE  0.000185228741827\n",
      "RHO EIGENVALUE  0.000185736319616\n",
      "RHO EIGENVALUE  0.000186109182298\n",
      "RHO EIGENVALUE  0.000186193230433\n",
      "RHO EIGENVALUE  0.00202563758942\n",
      "RHO EIGENVALUE  0.00202724670848\n",
      "RHO EIGENVALUE  0.497562312955\n",
      "RHO EIGENVALUE  0.497641535273\n",
      "Truncation error =  -6.63813917317e-17\n",
      "RIGHT-TO-LEFT ITERATION  1 20 8\n",
      "Iter =  1  Ener =  -1.92212121947\n",
      "Iter =  2  Ener =  -2.79489029124\n",
      "Iter =  3  Ener =  -3.3123465457\n",
      "Iter =  4  Ener =  -3.83867495031\n",
      "Iter =  5  Ener =  -3.98326535104\n",
      "Iter =  6  Ener =  -4.0601538773\n",
      "Iter =  7  Ener =  -4.1746681408\n",
      "Iter =  8  Ener =  -4.23537542241\n",
      "Iter =  9  Ener =  -4.25422328103\n",
      "Iter =  10  Ener =  -4.25756671961\n",
      "Iter =  11  Ener =  -4.25798199913\n",
      "Iter =  12  Ener =  -4.25802497134\n",
      "Iter =  13  Ener =  -4.25802768389\n",
      "Iter =  14  Ener =  -4.25802808545\n",
      "Iter =  15  Ener =  -4.25802828983\n",
      "Iter =  16  Ener =  -4.25802837274\n",
      "E0 =  -4.25802837274\n",
      "RHO EIGENVALUE  0.0306009339058\n",
      "RHO EIGENVALUE  0.0306194552539\n",
      "RHO EIGENVALUE  0.0306412799572\n",
      "RHO EIGENVALUE  0.908138330883\n",
      "Truncation error =  0.0\n",
      "RIGHT-TO-LEFT ITERATION  2 20 4\n",
      "Iter =  1  Ener =  -1.33275015899\n",
      "Iter =  2  Ener =  -2.55619323725\n",
      "Iter =  3  Ener =  -3.10069575953\n",
      "Iter =  4  Ener =  -3.44972183078\n",
      "Iter =  5  Ener =  -3.72815968424\n",
      "Iter =  6  Ener =  -3.86818600857\n",
      "Iter =  7  Ener =  -3.92871338992\n",
      "Iter =  8  Ener =  -3.97597519323\n",
      "Iter =  9  Ener =  -4.03690252355\n",
      "Iter =  10  Ener =  -4.16534240165\n",
      "Iter =  11  Ener =  -4.24121240809\n",
      "Iter =  12  Ener =  -4.25609863356\n",
      "Iter =  13  Ener =  -4.25782889177\n",
      "Iter =  14  Ener =  -4.25800770497\n",
      "Iter =  15  Ener =  -4.25802605209\n",
      "Iter =  16  Ener =  -4.25802789252\n",
      "Iter =  17  Ener =  -4.25802822287\n",
      "Iter =  18  Ener =  -4.2580283165\n",
      "E0 =  -4.2580283165\n",
      "RHO EIGENVALUE  0.000185143623989\n",
      "RHO EIGENVALUE  0.000185673202304\n",
      "RHO EIGENVALUE  0.000185992593001\n",
      "RHO EIGENVALUE  0.000186521374319\n",
      "RHO EIGENVALUE  0.00202665258691\n",
      "RHO EIGENVALUE  0.00202983542623\n",
      "RHO EIGENVALUE  0.497261734023\n",
      "RHO EIGENVALUE  0.49793844717\n",
      "Truncation error =  0.0\n",
      "RIGHT-TO-LEFT ITERATION  3 20 8\n",
      "Iter =  1  Ener =  -0.95310673237\n",
      "Iter =  2  Ener =  -2.30387827825\n",
      "Iter =  3  Ener =  -3.27355975417\n",
      "Iter =  4  Ener =  -3.79513137044\n",
      "Iter =  5  Ener =  -4.05861999208\n",
      "Iter =  6  Ener =  -4.14497006161\n",
      "Iter =  7  Ener =  -4.18536231319\n",
      "Iter =  8  Ener =  -4.22871259035\n",
      "Iter =  9  Ener =  -4.25122208997\n",
      "Iter =  10  Ener =  -4.25657665111\n",
      "Iter =  11  Ener =  -4.25767765096\n",
      "Iter =  12  Ener =  -4.25794255122\n",
      "Iter =  13  Ener =  -4.25801313273\n",
      "Iter =  14  Ener =  -4.25802897752\n",
      "Iter =  15  Ener =  -4.25803114229\n",
      "Iter =  16  Ener =  -4.25803146901\n",
      "Iter =  17  Ener =  -4.25803150628\n",
      "E0 =  -4.25803150628\n",
      "RHO EIGENVALUE  7.16479191158e-08\n",
      "RHO EIGENVALUE  7.21003014656e-08\n",
      "RHO EIGENVALUE  7.24384255307e-08\n",
      "RHO EIGENVALUE  7.40970543181e-08\n",
      "RHO EIGENVALUE  7.4167171091e-08\n",
      "RHO EIGENVALUE  4.55365603035e-07\n",
      "RHO EIGENVALUE  4.59280945459e-07\n",
      "RHO EIGENVALUE  4.62983987888e-07\n",
      "RHO EIGENVALUE  9.46203043804e-06\n",
      "RHO EIGENVALUE  3.41586978461e-05\n",
      "RHO EIGENVALUE  3.42054739324e-05\n",
      "RHO EIGENVALUE  3.42445500487e-05\n",
      "RHO EIGENVALUE  0.0391478449466\n",
      "RHO EIGENVALUE  0.0391526289111\n",
      "RHO EIGENVALUE  0.0391586977857\n",
      "RHO EIGENVALUE  0.882427015523\n",
      "Truncation error =  8.19816474556e-07\n",
      "RIGHT-TO-LEFT ITERATION  4 20 16\n",
      "Iter =  1  Ener =  -0.795445921687\n",
      "Iter =  2  Ener =  -2.23910274363\n",
      "Iter =  3  Ener =  -3.1529989682\n",
      "Iter =  4  Ener =  -3.7371884752\n",
      "Iter =  5  Ener =  -4.03268685516\n",
      "Iter =  6  Ener =  -4.1534306318\n",
      "Iter =  7  Ener =  -4.20775936531\n",
      "Iter =  8  Ener =  -4.23166833396\n",
      "Iter =  9  Ener =  -4.24534173724\n",
      "Iter =  10  Ener =  -4.25308054371\n",
      "Iter =  11  Ener =  -4.25646970466\n",
      "Iter =  12  Ener =  -4.25765756412\n",
      "Iter =  13  Ener =  -4.25794481229\n",
      "Iter =  14  Ener =  -4.25800857093\n",
      "Iter =  15  Ener =  -4.25802433348\n",
      "Iter =  16  Ener =  -4.25802794503\n",
      "Iter =  17  Ener =  -4.25802870506\n",
      "Iter =  18  Ener =  -4.25802887169\n",
      "Iter =  19  Ener =  -4.25802891159\n",
      "E0 =  -4.25802891159\n",
      "RHO EIGENVALUE  1.95330103338e-11\n",
      "RHO EIGENVALUE  3.36831518538e-11\n",
      "RHO EIGENVALUE  6.63083749743e-11\n",
      "RHO EIGENVALUE  8.38751277316e-11\n",
      "RHO EIGENVALUE  2.14931905983e-09\n",
      "RHO EIGENVALUE  2.68819893854e-09\n",
      "RHO EIGENVALUE  2.93468363403e-08\n",
      "RHO EIGENVALUE  3.39216442654e-08\n",
      "RHO EIGENVALUE  3.54233656023e-08\n",
      "RHO EIGENVALUE  3.72140509176e-08\n",
      "RHO EIGENVALUE  3.91308296268e-07\n",
      "RHO EIGENVALUE  4.08436375692e-07\n",
      "RHO EIGENVALUE  0.000272906579987\n",
      "RHO EIGENVALUE  0.000273996458402\n",
      "RHO EIGENVALUE  0.00027466006726\n",
      "RHO EIGENVALUE  0.000274762760591\n",
      "RHO EIGENVALUE  0.00286599908564\n",
      "RHO EIGENVALUE  0.00286819104061\n",
      "RHO EIGENVALUE  0.496563017523\n",
      "RHO EIGENVALUE  0.496605525793\n",
      "Truncation error =  1.40946814789e-07\n",
      "RIGHT-TO-LEFT ITERATION  5 20 20\n",
      "Iter =  1  Ener =  -1.12217506908\n",
      "Iter =  2  Ener =  -2.3956824749\n",
      "Iter =  3  Ener =  -3.12711277966\n",
      "Iter =  4  Ener =  -3.56578228981\n",
      "Iter =  5  Ener =  -3.84353581798\n",
      "Iter =  6  Ener =  -3.93720836374\n",
      "Iter =  7  Ener =  -3.99310293964\n",
      "Iter =  8  Ener =  -4.05367446244\n",
      "Iter =  9  Ener =  -4.1570081779\n",
      "Iter =  10  Ener =  -4.22796023646\n",
      "Iter =  11  Ener =  -4.2510773991\n",
      "Iter =  12  Ener =  -4.2568918522\n",
      "Iter =  13  Ener =  -4.25779339258\n",
      "Iter =  14  Ener =  -4.25799007566\n",
      "Iter =  15  Ener =  -4.25802190367\n",
      "Iter =  16  Ener =  -4.25802938578\n",
      "Iter =  17  Ener =  -4.25803113742\n",
      "Iter =  18  Ener =  -4.25803146509\n",
      "Iter =  19  Ener =  -4.2580315085\n",
      "E0 =  -4.2580315085\n",
      "RHO EIGENVALUE  -2.40164312377e-18\n",
      "RHO EIGENVALUE  -2.16112997627e-20\n",
      "RHO EIGENVALUE  -6.61256997768e-21\n",
      "RHO EIGENVALUE  9.95142705423e-20\n",
      "RHO EIGENVALUE  7.31251243696e-08\n",
      "RHO EIGENVALUE  7.41611898897e-08\n",
      "RHO EIGENVALUE  7.45194051311e-08\n",
      "RHO EIGENVALUE  7.480363981e-08\n",
      "RHO EIGENVALUE  7.56835109032e-08\n",
      "RHO EIGENVALUE  4.57104822962e-07\n",
      "RHO EIGENVALUE  4.59597722469e-07\n",
      "RHO EIGENVALUE  4.64841832623e-07\n",
      "RHO EIGENVALUE  9.44974021141e-06\n",
      "RHO EIGENVALUE  3.40994360646e-05\n",
      "RHO EIGENVALUE  3.42645475916e-05\n",
      "RHO EIGENVALUE  3.42842631702e-05\n",
      "RHO EIGENVALUE  0.0391596237914\n",
      "RHO EIGENVALUE  0.0391655168894\n",
      "RHO EIGENVALUE  0.0391745603737\n",
      "RHO EIGENVALUE  0.882386447121\n",
      "Truncation error =  8.29397693063e-07\n",
      "RIGHT-TO-LEFT ITERATION  6 16 20\n",
      "Iter =  1  Ener =  -1.45657734249\n",
      "Iter =  2  Ener =  -2.63041414074\n",
      "Iter =  3  Ener =  -3.33654457501\n",
      "Iter =  4  Ener =  -3.67446056243\n",
      "Iter =  5  Ener =  -3.81953633083\n",
      "Iter =  6  Ener =  -3.88651626923\n",
      "Iter =  7  Ener =  -3.91673293114\n",
      "Iter =  8  Ener =  -3.92736486491\n",
      "Iter =  9  Ener =  -3.93147077365\n",
      "Iter =  10  Ener =  -3.95251709122\n",
      "Iter =  11  Ener =  -4.18302696811\n",
      "Iter =  12  Ener =  -4.245427654\n",
      "Iter =  13  Ener =  -4.25588105369\n",
      "Iter =  14  Ener =  -4.25755285759\n",
      "Iter =  15  Ener =  -4.25794292985\n",
      "Iter =  16  Ener =  -4.25801352701\n",
      "Iter =  17  Ener =  -4.25802393455\n",
      "Iter =  18  Ener =  -4.25802609257\n",
      "Iter =  19  Ener =  -4.25802746613\n",
      "Iter =  20  Ener =  -4.25802821891\n",
      "Iter =  21  Ener =  -4.25802839585\n",
      "Iter =  22  Ener =  -4.2580284176\n",
      "E0 =  -4.2580284176\n",
      "RHO EIGENVALUE  -5.13370127552e-18\n",
      "RHO EIGENVALUE  -7.46566422189e-19\n",
      "RHO EIGENVALUE  -4.40083166632e-19\n",
      "RHO EIGENVALUE  -8.1189794009e-20\n",
      "RHO EIGENVALUE  -1.07299626252e-20\n",
      "RHO EIGENVALUE  -2.19121482723e-21\n",
      "RHO EIGENVALUE  3.74012610711e-20\n",
      "RHO EIGENVALUE  1.09764255428e-19\n",
      "RHO EIGENVALUE  5.29058552692e-19\n",
      "RHO EIGENVALUE  1.35364228342e-18\n",
      "RHO EIGENVALUE  2.18197629279e-18\n",
      "RHO EIGENVALUE  2.98795119678e-17\n",
      "RHO EIGENVALUE  0.000185116085728\n",
      "RHO EIGENVALUE  0.000185836411887\n",
      "RHO EIGENVALUE  0.000186151861082\n",
      "RHO EIGENVALUE  0.000186299930401\n",
      "RHO EIGENVALUE  0.00202593716227\n",
      "RHO EIGENVALUE  0.00202747866275\n",
      "RHO EIGENVALUE  0.497564724179\n",
      "RHO EIGENVALUE  0.497638455707\n",
      "Truncation error =  -4.3845954832e-18\n"
     ]
    }
   ],
   "source": [
    "nsites = 10\n",
    "n_states_to_keep = 10\n",
    "n_sweeps = 4\n",
    "S = DMRGSystem(nsites)\n",
    "###############################################################################\n",
    "for iter in range(1,nsites/2): # do infinite size dmrg for warmup\n",
    "    print \"WARMUP ITERATION \", iter, S.dim_l, S.dim_r\n",
    "    # Create HL and HR by adding the single sites to the two blocks\n",
    "    S.BuildBlockLeft(iter)\n",
    "    S.BuildBlockRight(iter)\n",
    "    # find smallest eigenvalue and eigenvector\n",
    "    S.GroundState()\n",
    "    # Calculate density matrix\n",
    "    S.DensityMatrix(Position.LEFT)\n",
    "    # Truncate\n",
    "    S.Truncate(Position.LEFT,n_states_to_keep)\n",
    "    # Reflect\n",
    "    S.DensityMatrix(Position.RIGHT)\n",
    "    S.Truncate(Position.RIGHT,n_states_to_keep)\n",
    "    \n",
    "first_iter = nsites/2\n",
    "for sweep in range(1,n_sweeps):\n",
    "    for iter in range(first_iter, nsites-3):\n",
    "        print \"LEFT-TO-RIGHT ITERATION \", iter, S.dim_l, S.dim_r\n",
    "        # Create HL and HR by adding the single sites to the two blocks\n",
    "        S.BuildBlockLeft(iter)\n",
    "        S.BuildBlockRight(nsites-iter-2)\n",
    "        # find smallest eigenvalue and eigenvector\n",
    "        S.GroundState()\n",
    "        # Calculate density matrix\n",
    "        S.DensityMatrix(Position.LEFT)\n",
    "        # Truncate\n",
    "        S.Truncate(Position.LEFT,n_states_to_keep)\n",
    "    first_iter = 1;\n",
    "    for iter in range(first_iter, nsites-3):\n",
    "        print \"RIGHT-TO-LEFT ITERATION \", iter, S.dim_l, S.dim_r\n",
    "        # Create HL and HR by adding the single sites to the two blocks\n",
    "        S.BuildBlockRight(iter);\n",
    "        S.BuildBlockLeft(nsites-iter-2)\n",
    "        # find smallest eigenvalue and eigenvector\n",
    "        S.GroundState();\n",
    "        # Calculate density matrix\n",
    "        S.DensityMatrix(Position.RIGHT)\n",
    "        # Truncate\n",
    "        S.Truncate(Position.RIGHT,n_states_to_keep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}