Update documentation

These are changes in the documentation made by Markus. They
should be compatible with the latest version of the triqs
library 1.0.

doc/Ce-HI.rst

@@ -77,7 +77,7 @@ In order to run LDA+DMFT calculations within Hubbard-I we need the corresponding
 It is generally similar to the script for the case of DMFT calculations with the CT-QMC solver (see :ref:`advanced`), 
 however there are also some differences. First, instead of *pytriqs.applications.dft.solver_multiband* we import Hubbard-I solver ::
 
-   from pytriqs.applications.impurity_solvers.hubbard_I.solver import Solver
+   from pytriqs.applications.impurity_solvers.hubbard_I.hubbard_solver import Solver
 
 The Hubbard-I solver is very fast and we do not need to take into account the LDA blocking structure or use any approximation for the *U*-matrix ::
 
@@ -87,18 +87,19 @@ The Hubbard-I solver is very fast and we do not need to take into account the LD
 We load and convert the :program:`dmftproj` output and initialize the *SumkLDA* class as described in :ref:`LDADMFTmain` and :ref:`advanced` and then set up the Hubbard-I solver ::
 
  
-   S = Solver(beta = beta, U_int = U_int, J_hund = J_hund, l = l)
+   S = Solver(beta = beta, l = l)
-   S.Nmoments=10
 
-where the solver is initialized with the value of `beta` as well  as the `U` parameter (`U_int`) and Hund's rule coupling `J_hund`. Notice that `Solver_Hubbard-I` constructs the full 4-index `U`-matrix by default, and the `U` parameter is in fact the Slatter `F0` integral. 
+where the solver is initialized with the value of `beta`, and the orbital quantum number `l` (equal to 3 in our case). 
-The last necessary parameter is the orbital quantum number `l` (equal to 3 in our case). 
-The next line gives the number of self-energy momenta used to compute contribution from the high-frequency tails.
 
-The Hubbard-I solver initialization `Solver` has also several optional parameters one may use:
+
+The Hubbard-I initialization `Solver` has also optional parameters one may use:
 
   * `n_msb`: is the number of Matsubara frequencies used (default is `n_msb=1025`)
-  * `T`: A matrix that transforms the interaction matrix from complex spherical harmonics to a symmetry adapted basis. By default complex spherical harmonics basis is used and `T=None`
   * `use_spin_orbit`: if set 'True' the solver is run with spin-orbit coupling included. To perform actual LDA+DMFT calculations with spin-orbit one should also run   :program:`Wien2k` and :program:`dmftproj` in spin-polarized mode and with spin-orbit included. By default `use_spin_orbit=False`
+
+The `Solver.solve(U_int, J_hund)` statement has two necessary parameters, the `U` parameter (`U_int`) and Hund's rule coupling `J_hund`. Notice that the solver constructs the full 4-index `U`-matrix by default, and the `U` parameter is in fact the Slatter `F0` integral. Other optional parameters are:
+
+  * `T`: A matrix that transforms the interaction matrix from complex spherical harmonics to a symmetry adapted basis. By default complex spherical harmonics basis is used and `T=None`
   * `verbosity` tunes output from the solver. If `verbosity=0` only basic information is printed, if `verbosity=1` the ground state atomic occupancy and its energy are printed, if `verbosity=2` additional information is printed for all occupancies that were diagonalized. By default `verbosity=0`
 
 We need also to introduce some changes in the DMFT loop with respect to the ones used for CT-QMC calculations in :ref:`advanced`. 

doc/Ce-gamma.py

@@ -1,12 +1,12 @@
 from pytriqs.applications.dft.sumk_lda import *
 from pytriqs.applications.dft.converters.wien2k_converter import *
-from pytriqs.applications.impurity_solvers.hubbard_I.solver import Solver
+from pytriqs.applications.impurity_solvers.hubbard_I.hubbard_solver import Solver
 
-LDAFilename = 'Ce-gamma'
+LDAFilename = 'Ce'
 Beta = 40
 Uint = 6.00
 JHund = 0.70
-Loops =  3                       # Number of DMFT sc-loops
+Loops =  2                       # Number of DMFT sc-loops
 Mix = 0.7                        # Mixing factor in QMC
 DC_type = 0                      # 0...FLL, 1...Held, 2... AMF, 3...Lichtenstein
 DC_Mix = 1.0                     # 1.0 ... all from imp; 0.0 ... all from Gloc   
@@ -17,7 +17,7 @@ HDFfilename = LDAFilename+'.h5'
 
 # Convert DMFT input:
 # Can be commented after the first run
-Converter = Wien2kConverter(filename=LDAFilename,repacking=True)
+Converter = Wien2kConverter(filename=LDAFilename)
 Converter.convert_dmft_input()
 
 #check if there are previous runs:
@@ -45,8 +45,7 @@ Norb = SK.corr_shells[0][3]
 l    = SK.corr_shells[0][2]
 
 # Init the Solver:
-S = Solver(Beta = Beta, Uint = Uint, JHund = JHund, l = l, Verbosity=2)
+S = Solver(beta = Beta, l = l)
-S.Nmoments=10
 
 if (previous_present):
     # load previous data:
@@ -64,21 +63,21 @@ for Iteration_Number in range(1,Loops+1):
         itn = Iteration_Number + previous_runs
        
         # put Sigma into the SumK class:
-        SK.put_Sigma(Sigmaimp = [ S.Sigma ])
+        SK.put_Sigma(Sigma_imp = [ S.Sigma ])
 
         # Compute the SumK, possibly fixing mu by dichotomy
-        if SK.Density_Required and (Iteration_Number > 0):
+        if SK.density_required and (Iteration_Number > 0):
-            Chemical_potential = SK.find_mu( precision = 0.000001 )
+            Chemical_potential = SK.find_mu( precision = 0.01 )
         else:
             mpi.report("No adjustment of chemical potential\nTotal density  = %.3f"%SK.total_density(mu=Chemical_potential))
 
         # Density:
-        S.G <<= SK.extract_Gloc()[0]
+        S.G <<= SK.extract_G_loc()[0]
         mpi.report("Total charge of Gloc : %.6f"%S.G.total_density())
         dm = S.G.density()
 
         if ((Iteration_Number==1)and(previous_present==False)):
-	    SK.SetDoubleCounting( dm, U_interact = Uint, J_Hund = JHund, orb = 0, useDCformula = DC_type)
+	    SK.set_dc( dens_mat=dm, U_interact = Uint, J_hund = JHund, orb = 0, use_dc_formula = DC_type)
 
         # set atomic levels:
         eal = SK.eff_atomic_levels()[0]
@@ -91,7 +90,7 @@ for Iteration_Number in range(1,Loops+1):
             del ar
 
         # solve it:
-        S.Solve()
+        S.solve(U_int = Uint, J_hund = JHund, verbosity = 1)
 
         if (mpi.is_master_node()):
             ar = HDFArchive(HDFfilename)
@@ -99,7 +98,7 @@ for Iteration_Number in range(1,Loops+1):
  
         # Now mix Sigma and G:
         if ((itn>1)or(previous_present)):
-            if (mpi.is_master_node()):
+            if (mpi.is_master_node()and (Mix<1.0)):
                 mpi.report("Mixing Sigma and G with factor %s"%Mix)
                 if ('SigmaF' in ar):
                     S.Sigma <<= Mix * S.Sigma + (1.0-Mix) * ar['SigmaF']
@@ -117,13 +116,13 @@ for Iteration_Number in range(1,Loops+1):
         
         # after the Solver has finished, set new double counting: 
         dm = S.G.density()
-        SK.SetDoubleCounting( dm, U_interact = Uint, J_Hund = JHund, orb = 0, useDCformula = DC_type )
+        SK.set_dc( dm, U_interact = Uint, J_hund = JHund, orb = 0, use_dc_formula = DC_type )
         # correlation energy calculations:
         correnerg = 0.5 * (S.G * S.Sigma).total_density()
         mpi.report("Corr. energy = %s"%correnerg)
         if (mpi.is_master_node()):
             ar['correnerg%s'%itn] = correnerg
-            ar['DCenerg%s'%itn] = SK.DCenerg
+            ar['DCenerg%s'%itn] = SK.dc_energ
             del ar
 
 
@@ -150,9 +149,9 @@ for Iteration_Number in range(1,Loops+1):
 
 
 # find exact chemical potential
-if (SK.Density_Required):
+if (SK.density_required):
-    SK.Chemical_potential = SK.find_mu( precision = 0.000001 )
+    SK.chemical_potential = SK.find_mu( precision = 0.000001 )
-dN,d = SK.calc_DensityCorrection(Filename = LDAFilename+'.qdmft')
+dN,d = SK.calc_density_correction(filename = LDAFilename+'.qdmft')
 
 mpi.report("Trace of Density Matrix: %s"%d)
 
@@ -168,4 +167,3 @@ if (mpi.is_master_node()):
     f.write("%.16f\n"%correnerg)
     f.close()
 
-

doc/LDADMFTmain.rst

@@ -41,15 +41,23 @@ Setting up the Multi-Band Solver
 There is a module that helps setting up the multiband CTQMC solver. It is loaded and initialized by::
 
   from pytriqs.applications.dft.solver_multiband import *
-  S = SolverMultiBand(Beta, U_interact, J_Hund, Norb)
+  S = SolverMultiBand(beta, n_orb, gf_struct = SK.gf_struct_solver[0], map=SK.map[0])
 
 The necessary parameters are the inverse temperature `beta`, the Coulomb interaction `U_interact`, the Hund's rule coupling `J_hund`,
 and the number of orbitals `n_orb`. There are again several optional parameters that allow to modify the local Hamiltonian to
 specific needs. They are:
 
   * `gf_struct`: Contains the block structure of the local density matrix. Has to be given in the format as calculated by :class:`SumkLDA`.
-  * `map`: If `gf_Struct` is given as parameter, also `map` has to be given. This is the mapping from the block structure to a general 
+  * `map`: If `gf_struct` is given as parameter, also `map` has to be given. This is the mapping from the block structure to a general 
     up/down structure.
+
+The solver method is called later by this statement::
+
+  S.solve(U_interact = U, J_hund = J)
+
+The parameters for the Coulomb interaction `U_interact` and the Hunds coupling `J_hund` are necessary parameters.
+The following parameters are optional, by highly recommended to be set:
+
   * `use_matrix`: If `True`, the interaction matrix is calculated from Slater integrals, which are calculated from `U_interact` and 
     `J_hund`. Otherwise, a Kanamori representation is used. Attention: We define the intraorbital interaction as 
     `U_interact+2J_hund`, the interorbital interaction for opposite spins as `U_interact`, and interorbital for equal spins as 
@@ -69,8 +77,8 @@ at the end of this tutorial.
 
 After initialisation, several other CTQMC parameters can be set (see CTQMC doc). The most important are:
 
-  * `S.N_Cycles`: Number of QMC cycles per node.
+  * `S.n_cycles`: Number of QMC cycles per node.
-  * `S.N_Warmup_Cycles`: Number of iterations used for thermalisation
+  * `S.n_warmup_cycles`: Number of iterations used for thermalisation
 
 
 
@@ -91,7 +99,7 @@ set up the loop over DMFT iterations and the self-consistency condition::
           S.G <<= SK.extract_G_loc()[0]              # extract the local Green function
           S.G0 <<= inverse(S.Sigma + inverse(S.G))   # finally get G0, the input for the Solver
 
-          S.Solve()                                  # now solve the impurity problem
+          S.Solve(U_interact = U, J_hund = J)                                  # now solve the impurity problem
 
 	  dm = S.G.density()                         # density matrix of the impurity problem  
           SK.set_dc( dm, U_interact = U, J_hund = J, use_dc_formula = 0)     # Set the double counting term
@@ -112,7 +120,7 @@ At the end of the calculation, we can save the Greens function and self energy i
   from pytriqs.archive import HDFArchive
   import pytriqs.utility.mpi as mpi
   if mpi.is_master_node():
-      R = HDFArchive("single_site_bethe.h5",'w')
+      R = HDFArchive("YourLDADMFTcalculation.h5",'w')
       R["G"] = S.G
       R["Sigma"] = S.Sigma
 

doc/advanced.rst

@@ -64,16 +64,14 @@ The next step is to initialise the Solver::
 
   Norb = SK.corr_shells[0][3]
   l = SK.corr_shells[0][2]
-  S = SolverMultiBand(beta=beta,U_interact=U,J_hund=J,n_orb=Norb,use_matrix=use_matrix, 
+  S = SolverMultiBand(beta=beta,n_orb=Norb,gf_struct=SK.gf_struct_solver[0],map=SK.map[0])
-                     T=SK.T[0], gf_struct=SK.gf_struct_solver[0],map=SK.map[0], 
-                     l=l, deg_orbs=SK.deg_shells[0], use_spinflip=use_spinflip)
 
 As we can see, many options of the solver are set by properties of the :class:`SumkLDA` class, so we don't have
 to set them manually. We now set the basic parameters of the QMC solver::
 
-  S.N_Cycles  = qmc_cycles
+  S.n_cycles  = qmc_cycles
-  S.Length_Cycle = length_cycle
+  S.length_cycle = length_cycle
-  S.N_Warmup_Cycles = warming_iterations
+  S.n_warmup_cycles = warming_iterations
 
 If there are previous runs stored in the hdf5 archive, we can now load the self energy
 of the last iteration::
@@ -121,7 +119,9 @@ previous section, with some additional refinement::
         S.G0 = mpi.bcast(S.G0)
 
         # Solve the impurity problem:
-        S.Solve()
+        S.Solve(U_interact=U,J_hund=J,n_orb=Norb,use_matrix=use_matrix, 
+                T=SK.T[0], gf_struct=SK.gf_struct_solver[0],map=SK.map[0], 
+                l=l, deg_orbs=SK.deg_shells[0], use_spinflip=use_spinflip))
 
         # solution done, do the post-processing:
         mpi.report("Total charge of impurity problem : %.6f"%S.G.total_density())

doc/analysis.rst

@@ -43,7 +43,7 @@ density of states of the Wannier orbitals, you simply type::
 
   SK.check_input_dos(om_min, om_max, n_om)
 
-which produces plots between real frequencies `ommin` and `ommax`, using a mesh of `N_om` points. There
+which produces plots between real frequencies `om_min` and `om_max`, using a mesh of `n_om` points. There
 is an optional parameter, `broadening`, which defines an additional Lorentzian broadening, and is set to `0.01` 
 by default.
 

doc/interface.rst

@@ -5,7 +5,7 @@ The interface
 
 The basic function of the interface to the Wien2k program package is
 to take the output of the program that constructs the projected local
-orbitals (:program:`dmftproj`), and to store all the necessary information into
+orbitals (:program:`dmftproj`, for documentation see :download:`TutorialDmftproj.pdf <TutorialDmftproj.pdf>`), and to store all the necessary information into
 an hdf5 file. This latter file is then used to do the DMFT calculation. The
 reason for this structure is that this enables the user to have everything
 that is necessary to reproduce the calculation in one single hdf5 arxive.