From 9f08ec1d80de8174752eed8d27f257e81cd52cbc Mon Sep 17 00:00:00 2001 From: Priyanka Seth Date: Wed, 11 Mar 2015 14:35:28 +0100 Subject: [PATCH] [doc] updates --- doc/DFTDMFTmain.rst | 151 +++++++++++++++---------- doc/advanced.rst | 203 ++++++++++++++++++---------------- doc/interface.rst | 46 ++++---- doc/reference/h5structure.rst | 2 +- 4 files changed, 227 insertions(+), 175 deletions(-) diff --git a/doc/DFTDMFTmain.rst b/doc/DFTDMFTmain.rst index 0fc34454..3e5ec6f3 100644 --- a/doc/DFTDMFTmain.rst +++ b/doc/DFTDMFTmain.rst @@ -1,5 +1,7 @@ .. index:: DFT+DMFT calculation +.. highlight:: python + .. _DFTDMFTmain: The DFT+DMFT calculation @@ -20,64 +22,93 @@ to get the local quantities used in DMFT. It is initialized by:: from pytriqs.applications.dft.sumk_dft import * SK = SumkDFT(hdf_file = filename) -The only necessary parameter is the filename of the hdf5 archive. In addition, there are some optional parameters: - * `mu`: The chemical potential at initialization. This value is only used if no other value is found in the hdf5 archive. The default value is 0.0. - * `h_field`: External magnetic field. The default value is 0.0. - * `use_dft_blocks`: If true, the structure of the density matrix is analysed at initialisation, and non-zero matrix elements - are identified. The DMFT calculation is then restricted to these matrix elements, yielding a more efficient solution of the - local interaction problem. Degeneracies in orbital and spin space are also identified and stored for later use. The default value is `False`. - * `dft_data`, `symmcorr_data`, `parproj_data`, `symmpar_data`, `bands_data`: These string variables define the subgroups in the hdf5 archive, - where the corresponding information is stored. The default values are consistent with those in :ref:`interfacetowien`. +This is the reference for the function: -At initialisation, the necessary data is read from the hdf5 file. If a calculation is restarted based on a previous hdf5 file, information on -degenerate shells, the block structure of the density matrix, the chemical potential, and double counting correction is also read in. +.. function:: SumkDFT(hdf_file, h_field = 0.0, use_dft_blocks = False, dft_data = 'dft_input', symmcorr_data = 'dft_symmcorr_input', parproj_data = 'dft_parproj_input', symmpar_data = 'dft_symmpar_input', bands_data = 'dft_bands_input', transp_data = 'dft_transp_input', misc_data = 'dft_misc_input') + +The parameters needed to initialise SumkDFT as as follows (with any default variables as shown above): + +========================= ==================== =========================================================================== +Name Type Meaning +========================= ==================== =========================================================================== +hdf_file String Name of the main hdf5 file containing converted dft information. +h_field Scalar External magnetic field. +use_dft_blocks Boolean Analyse the structure of the density matrix at initialisation, + and identify non-zero matrix elements. + The DMFT calculation is then restricted to these matrix elements, + yielding a more efficient solution of the local interaction problem. + Degeneracies in orbital and spin space are also identified and stored for later use. +dft_data String hdf5 subgroup containing required DFT data. +symmcorr_data String hdf5 subgroup containing correlated shell symmetry data. +parproj_data String hdf5 subgroup containing partial projector data. +symmpar_data String hdf5 subgroup containing non-correlated shell symmetry data. +bands_data String hdf5 subgroup containing DFT band data. +transp_data String hdf5 subgroup containing optics/transport data. +misc_data String hdf5 subgroup containing miscellaneous DFT data. +========================= ==================== =========================================================================== .. index:: Multiband solver Setting up the Multi-Band Solver -------------------------------- -There is a module that helps setting up the multiband CTQMC solver. It is loaded and initialized by:: +The next step is to setup the impurity solver. +For more details here, see the `CTHYB `_ documentation. - from pytriqs.applications.dft.solver_multiband import * - 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 the tailoring of the local Hamiltonian to -specific needs. They are: - - * `gf_struct`: The block structure of the local density matrix given in the format calculated by :class:`SumkDFT`. - * `map`: If `gf_struct` is given as parameter, `map` also must 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,J_hund,use_spinflip=False,use_matrix=True, - l=2,T=None, dim_reps=None, irep=None, n_cycles =10000, - length_cycle=200,n_warmup_cycles=1000) - -The parameters for the Coulomb interaction `U_interact` and the Hund's coupling `J_hund` are necessary input parameters. The rest are optional -parameters for which default values are set. Generally, they should be reset for the problem at hand. Here is a description of the parameters: - - * `use_matrix`: If `True`, the interaction matrix is calculated from Slater integrals, which are computed from `U_interact` and - `J_hund`. Otherwise, a Kanamori representation is used. Attention: We define the intraorbital interaction as - `U_interact`, the interorbital interaction for opposite spins as `U_interact-2*J_hund`, and interorbital for equal spins as - `U_interact-3*J_hund`. - * `T`: The matrix that transforms the interaction matrix from spherical harmonics to a symmetry-adapted basis. Only effective for Slater - parametrisation, i.e. `use_matrix=True`. - * `l`: The orbital quantum number. Again, only effective for Slater parametrisation, i.e. `use_matrix=True`. - * `use_spinflip`: If `True`, the full rotationally-invariant interaction is used. Otherwise, only density-density terms are - kept in the local Hamiltonian. - * `dim_reps`: If only a subset of the full d-shell is used as correlated orbtials, one can specify here the dimensions of all the subspaces - of the d-shell, i.e. t2g and eg. Only effective for Slater parametrisation. - * `irep`: The index in the list `dim_reps` of the subset that is used. Only effective for Slater parametrisation. - * `n_cycles`: Number of CTQMC cycles (a sequence of moves followed by a measurement) per core. The default value of 10000 is the minimum, and generally should be increased. - * `length_cycle`: Number of CTQMC moves per one cycle. - * `n_warmup_cycles`: Number of initial CTQMC cycles before measurements start. Usually of order of 10000, sometimes needs to be increased significantly. - -Most of above parameters can be taken directly from the :class:`SumkDFT` class, without defining them by hand. We will see a specific example -at the end of this tutorial. +.. This is initialised as follows:: +.. +.. from pytriqs.applications.impurity_solvers.cthyb import * +.. beta = 40.0 +.. gf_struct = SK.gf_struct_solver[0] +.. S = Solver(beta=beta, gf_struct=gf_struct) +.. +.. The solver method is called later by this statement:: +.. +.. S.solve(h_loc=h_loc, **p) +.. +.. where `p` represents the solve parameters. +.. +.. 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, 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 the tailoring of the local Hamiltonian to +.. specific needs. They are: +.. +.. * `gf_struct`: The block structure of the local density matrix given in the format calculated by :class:`SumkDFT`. +.. * `map`: If `gf_struct` is given as parameter, `map` also must 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,J_hund,use_spinflip=False,use_matrix=True, +.. l=2,T=None, dim_reps=None, irep=None, n_cycles =10000, +.. length_cycle=200,n_warmup_cycles=1000) +.. +.. The parameters for the Coulomb interaction `U_interact` and the Hund's coupling `J_hund` are necessary input parameters. The rest are optional +.. parameters for which default values are set. Generally, they should be reset for the problem at hand. Here is a description of the parameters: +.. +.. * `use_matrix`: If `True`, the interaction matrix is calculated from Slater integrals, which are computed from `U_interact` and +.. `J_hund`. Otherwise, a Kanamori representation is used. Attention: We define the intraorbital interaction as +.. `U_interact`, the interorbital interaction for opposite spins as `U_interact-2*J_hund`, and interorbital for equal spins as +.. `U_interact-3*J_hund`. +.. * `T`: The matrix that transforms the interaction matrix from spherical harmonics to a symmetry-adapted basis. Only effective for Slater +.. parametrisation, i.e. `use_matrix=True`. +.. * `l`: The orbital quantum number. Again, only effective for Slater parametrisation, i.e. `use_matrix=True`. +.. * `use_spinflip`: If `True`, the full rotationally-invariant interaction is used. Otherwise, only density-density terms are +.. kept in the local Hamiltonian. +.. * `dim_reps`: If only a subset of the full d-shell is used as correlated orbtials, one can specify here the dimensions of all the subspaces +.. of the d-shell, i.e. t2g and eg. Only effective for Slater parametrisation. +.. * `irep`: The index in the list `dim_reps` of the subset that is used. Only effective for Slater parametrisation. +.. * `n_cycles`: Number of CTQMC cycles (a sequence of moves followed by a measurement) per core. The default value of 10000 is the minimum, and generally should be increased. +.. * `length_cycle`: Number of CTQMC moves per one cycle. +.. * `n_warmup_cycles`: Number of initial CTQMC cycles before measurements start. Usually of order of 10000, sometimes needs to be increased significantly. +.. +.. Most of above parameters can be taken directly from the :class:`SumkDFT` class, without defining them by hand. We will see a specific example +.. at the end of this tutorial. .. index:: DFT+DMFT loop, one-shot calculation @@ -91,18 +122,16 @@ set up the loop over DMFT iterations and the self-consistency condition:: n_loops = 5 for iteration_number in range(n_loops) : # start the DMFT loop - SK.put_Sigma(Sigma_imp = [ S.Sigma ]) # Put self energy to the SumK class - chemical_potential = SK.calc_mu() # calculate the chemical potential for the given density - 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 + SK.put_Sigma(Sigma_imp = [ S.Sigma ]) # Put self energy to the SumK class + chemical_potential = SK.calc_mu() # calculate the chemical potential for the given density + S.G_iw << SK.extract_G_loc()[0] # extract the local Green function + S.G0_iw << inverse(S.Sigma_iw + inverse(S.G_iw)) # finally get G0, the input for the Solver - S.solve(U_interact,J_hund,use_spinflip=False,use_matrix=True, # now solve the impurity problem - l=2,T=None, dim_reps=None, irep=None, n_cycles =10000, - length_cycle=200,n_warmup_cycles=1000) + S.solve(h_loc=h_loc, **p) # now solve the impurity problem - dm = S.G.density() # Density matrix of the impurity problem - SK.calc_dc( dm, U_interact = U, J_hund = J, use_dc_formula = 0) # Set the double counting term - SK.save(['chemical_potential','dc_imp','dc_energ']) # Save data in the hdf5 archive + dm = S.G_iw.density() # Density matrix of the impurity problem + SK.calc_dc(dm, U_interact=U, J_hund=J, orb=0, use_dc_formula=dc_type) # Set the double counting term + SK.save(['chemical_potential','dc_imp','dc_energ']) # Save data in the hdf5 archive These basic steps are enough to set up the basic DMFT Loop. For a detailed description of the :class:`SumkDFT` routines, see the reference manual. After the self-consistency steps, the solution of the Anderson impurity problem is calculation by CTQMC. @@ -120,8 +149,8 @@ At the end of the calculation, we can save the Greens function and self energy i import pytriqs.utility.mpi as mpi if mpi.is_master_node(): ar = HDFArchive("YourDFTDMFTcalculation.h5",'w') - ar["G"] = S.G - ar["Sigma"] = S.Sigma + ar["G"] = S.G_iw + ar["Sigma"] = S.Sigma_iw This is it! diff --git a/doc/advanced.rst b/doc/advanced.rst index a9022346..f1056b48 100644 --- a/doc/advanced.rst +++ b/doc/advanced.rst @@ -9,9 +9,11 @@ First, we load the necessary modules:: from pytriqs.applications.dft.sumk_dft import * from pytriqs.applications.dft.converters.wien2k_converter import * - from pytriqs.applications.dft.solver_multiband import * from pytriqs.gf.local import * - from pytriqs.archive import * + from pytriqs.archive import HDFArchive + from pytriqs.operators.hamiltonians import * + from pytriqs.applications.impurity_solvers.cthyb import * + Then we define some parameters:: @@ -19,20 +21,20 @@ Then we define some parameters:: U = 2.7 J = 0.65 beta = 40 - loops = 10 # Number of DMFT sc-loops - mix = 0.8 # Mixing factor of Sigma after solution of the AIM - Delta_mix = 1.0 # Mixing factor of Delta as input for the AIM + loops = 10 # Number of DMFT sc-loops + sigma_mix = 0.8 # Mixing factor of Sigma after solution of the AIM + delta_mix = 1.0 # Mixing factor of Delta as input for the AIM dc_type = 1 # DC type: 0 FLL, 1 Held, 2 AMF use_blocks = True # use bloc structure from DFT input - use_matrix = False # True: Slater parameters, False: Kanamori parameters U+2J, U, U-J - use_spinflip = False # use the full rotational invariant interaction? prec_mu = 0.0001 - qmc_cycles = 20000 - length_cycle = 200 - warming_iterations = 2000 + # Solver parameters + p = {} + p["length_cycle"] = 200 + p["n_warmup_cycles"] = 2000 + p["n_cycles"] = 20000 -Most of these parameters are self-explaining. The first, `dft_filename`, gives the filename of the input files. +Most of these parameters are self-explanatory. The first, `dft_filename`, gives the filename of the input files. The next step, as described in the previous section, is to convert the input files:: Converter = Wien2kConverter(filename=dft_filename, repacking=True) @@ -46,106 +48,119 @@ from scratch:: previous_runs = 0 previous_present = False if mpi.is_master_node(): - ar = HDFArchive(dft_filename+'.h5','a') - if 'iterations' in ar: - previous_present = True - previous_runs = ar['iterations'] - del ar + f = HDFArchive(dft_filename+'.h5','a') + if 'dmft_output' in f: + ar = f['dmft_output'] + if 'iterations' in ar: + previous_present = True + previous_runs = ar['iterations'] + else: + f.create_group('dmft_output') + del f previous_runs = mpi.bcast(previous_runs) previous_present = mpi.bcast(previous_present) - # if previous runs are present, no need for recalculating the bloc structure: - calc_blocs = use_blocks and (not previous_present) Now we can use all this information to initialise the :class:`SumkDFT` class:: - SK=SumkDFT(hdf_file=dft_filename+'.h5',use_dft_blocks=calc_blocs) + SK = SumkDFT(hdf_file=dft_filename+'.h5',use_dft_blocks=use_blocks) -If there was a previous run, we know already about the block structure, and therefore `UseDFTBlocs` is set to `False`. The next step is to initialise the Solver:: - Norb = SK.corr_shells[0]['dim'] + n_orb = SK.corr_shells[0]['dim'] l = SK.corr_shells[0]['l'] - S = SolverMultiBand(beta=beta,n_orb=Norb,gf_struct=SK.gf_struct_solver[0],map=SK.map[0]) - -As we can see, many options of the solver are set by properties of the :class:`SumkDFT` class, so we don't have -to set them manually. + spin_names = ["up","down"] + orb_names = [i for i in range(n_orb)] + # Use GF structure determined by DFT blocks + gf_struct = SK.gf_struct_solver[0] + # Construct U matrix for density-density calculations + Umat, Upmat = U_matrix_kanamori(n_orb=n_orb, U_int=U, J_hund=J) + # Construct Hamiltonian and solver + h_loc = h_loc_density(spin_names, orb_names, map_operator_structure=SK.sumk_to_solver[0], U=Umat, Uprime=Upmat, H_dump="H.txt") + S = Solver(beta=beta, gf_struct=gf_struct) If there are previous runs stored in the hdf5 archive, we can now load the self energy of the last iteration:: - if (previous_present): - if (mpi.is_master_node()): - ar = HDFArchive(dft_filename+'.h5','a') - S.Sigma << ar['SigmaImFreq'] - del ar - S.Sigma = mpi.bcast(S.Sigma) + if previous_present: + if mpi.is_master_node(): + S.Sigma_iw << HDFArchive(dft_filename+'.h5','a')['dmft_output']['Sigma_iw'] + chemical_potential,dc_imp,dc_energ = SK.load(['chemical_potential','dc_imp','dc_energ']) + S.Sigma_iw << mpi.bcast(S.Sigma_iw) + SK.set_mu(chemical_potential) + SK.set_dc(dc_imp,dc_energ) -The last command is the broadcasting of the self energy from the master node to the slave nodes. -Now we can go to the definition of the self-consistency step. It consists again of the basic steps discussed in the -previous section, with some additional refinement:: +The self-energy is broadcast from the master node to the slave nodes. Also, the +last saved chemical potential and double counting values are read in and set. - for iteration_number in range(1,loops+1) : - - SK.symm_deg_gf(S.Sigma,orb=0) # symmetrise Sigma - SK.put_Sigma(Sigma_imp = [ S.Sigma ]) # put Sigma into the SumK class: - - chemical_potential = SK.calc_mu( precision = prec_mu ) # find the chemical potential - S.G << SK.extract_G_loc()[0] # calculation of the local Green function - mpi.report("Total charge of Gloc : %.6f"%S.G.total_density()) - - if ((iteration_number==1)and(previous_present==False)): - # Init the DC term and the real part of Sigma, if no previous run was found: - dm = S.G.density() - SK.calc_dc( dm, U_interact = U, J_hund = J, orb = 0, use_dc_formula = dc_type) - S.Sigma << SK.dc_imp[0]['up'][0,0] - - S.G0 << inverse(S.Sigma + inverse(S.G)) - - # Solve the impurity problem: - S.solve(U_interact=U,J_hund=J,use_spinflip=use_spinflip,use_matrix=use_matrix, - l=l,T=SK.T[0], dim_reps=SK.dim_reps[0], irep=2, n_cycles=qmc_cycles, - length_cycle=length_cycle,n_warmup_cycles=warming_iterations) - - # solution done, do the post-processing: - mpi.report("Total charge of impurity problem : %.6f"%S.G.total_density()) - - S.Sigma <<(inverse(S.G0)-inverse(S.G)) - # Solve the impurity problem: - S.solve(U_interact=U,J_hund=J,use_spinflip=use_spinflip,use_matrix=use_matrix, - l=l,T=SK.T[0], dim_reps=SK.dim_reps[0], irep=2, n_cycles=qmc_cycles, - length_cycle=length_cycle,n_warmup_cycles=warming_iterations) - - # solution done, do the post-processing: - mpi.report("Total charge of impurity problem : %.6f"%S.G.total_density()) - - S.Sigma <<(inverse(S.G0)-inverse(S.G)) - - # Now mix Sigma and G with factor Mix, if wanted: - if ((iteration_number>1) or (previous_present)): - if (mpi.is_master_node()): - ar = HDFArchive(dft_filename+'.h5','a') - mpi.report("Mixing Sigma and G with factor %s"%mix) - S.Sigma << mix * S.Sigma + (1.0-mix) * ar['Sigma'] - S.G << mix * S.G + (1.0-mix) * ar['GF'] - del ar - S.G = mpi.bcast(S.G) - S.Sigma = mpi.bcast(S.Sigma) - - # Write the final Sigma and G to the hdf5 archive: - if (mpi.is_master_node()): - ar = HDFArchive(dft_filename+'.h5','a') - ar['iterations'] = previous_runs + iteration_number - ar['Sigma'] = S.Sigma - ar['GF'] = S.G - del ar +Now we can go to the definition of the self-consistency step. It consists again +of the basic steps discussed in the previous section, with some additional +refinement:: - # Now set new double counting: - dm = S.G.density() - SK.calc_dc( dm, U_interact = U, J_hund = J, orb = 0, use_dc_formula = dc_type) + for iteration_number in range(1,loops+1): + if mpi.is_master_node(): print "Iteration = ", iteration_number - #Save stuff: - SK.save(['chemical_potential','dc_imp','dc_energ']) - + SK.symm_deg_gf(S.Sigma_iw,orb=0) # symmetrise Sigma + SK.put_Sigma(Sigma_imp = [ S.Sigma_iw ]) # put Sigma into the SumK class + chemical_potential = SK.calc_mu( precision = prec_mu ) # find the chemical potential for given density + S.G_iw << SK.extract_G_loc()[0] # calc the local Green function + mpi.report("Total charge of Gloc : %.6f"%S.G_iw.total_density()) + + # Init the DC term and the real part of Sigma, if no previous runs found: + if (iteration_number==1 and previous_present==False): + dm = S.G_iw.density() + SK.calc_dc(dm, U_interact = U, J_hund = J, orb = 0, use_dc_formula = dc_type) + S.Sigma_iw << SK.dc_imp[0]['up'][0,0] + + # Calculate new G0_iw to input into the solver: + if mpi.is_master_node(): + # We can do a mixing of Delta in order to stabilize the DMFT iterations: + S.G0_iw << S.Sigma_iw + inverse(S.G_iw) + ar = HDFArchive(dft_filename+'.h5','a')['dmft_output'] + if (iteration_number>1 or previous_present): + mpi.report("Mixing input Delta with factor %s"%delta_mix) + Delta = (delta_mix * delta(S.G0_iw)) + (1.0-delta_mix) * ar['Delta_iw'] + S.G0_iw << S.G0_iw + delta(S.G0_iw) - Delta + ar['Delta_iw'] = delta(S.G0_iw) + S.G0_iw << inverse(S.G0_iw) + del ar + + S.G0_iw << mpi.bcast(S.G0_iw) + + # Solve the impurity problem: + S.solve(h_loc=h_loc, **p) + + # Solved. Now do post-processing: + mpi.report("Total charge of impurity problem : %.6f"%S.G_iw.total_density()) + + # Now mix Sigma and G with factor sigma_mix, if wanted: + if (iteration_number>1 or previous_present): + if mpi.is_master_node(): + ar = HDFArchive(dft_filename+'.h5','a')['dmft_output'] + mpi.report("Mixing Sigma and G with factor %s"%sigma_mix) + S.Sigma_iw << sigma_mix * S.Sigma_iw + (1.0-sigma_mix) * ar['Sigma_iw'] + S.G_iw << sigma_mix * S.G_iw + (1.0-sigma_mix) * ar['G_iw'] + del ar + S.G_iw << mpi.bcast(S.G_iw) + S.Sigma_iw << mpi.bcast(S.Sigma_iw) + + # Write the final Sigma and G to the hdf5 archive: + if mpi.is_master_node(): + ar = HDFArchive(dft_filename+'.h5','a')['dmft_output'] + if previous_runs: iteration_number += previous_runs + ar['iterations'] = iteration_number + ar['G_0'] = S.G0_iw + ar['G_tau'] = S.G_tau + ar['G_iw'] = S.G_iw + ar['Sigma_iw'] = S.Sigma_iw + del ar + + # Set the new double counting: + dm = S.G_iw.density() # compute the density matrix of the impurity problem + SK.calc_dc(dm, U_interact = U, J_hund = J, orb = 0, use_dc_formula = dc_type) + + # Save stuff into the dft_output group of hdf5 archive in case of rerun: + SK.save(['chemical_potential','dc_imp','dc_energ']) + This is all we need for the DFT+DMFT calculation. At the end, all results are stored in the hdf5 output file. diff --git a/doc/interface.rst b/doc/interface.rst index b97ca6ad..4f69933a 100644 --- a/doc/interface.rst +++ b/doc/interface.rst @@ -2,13 +2,14 @@ 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`, for documentation see :download:`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 archive. +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`, for documentation see +:download:`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 archive. .. index:: Interface to Wien2k @@ -31,17 +32,20 @@ calculation for TiO, the :program:`Wien2k` naming convention is that all files a :file:`TiO.*`, so you would give `filename = "TiO"`. The constructor opens an hdf5 archive, named :file:`material_of_interest.h5`, where all the data is stored. -There are three optional parameters to the Constructor: +These are the parameters to the Constructor: - * `dft_subgrp`: We store all data in subgroups of the hdf5 archive. For the main data - that is needed for the DMFT loop, we use the subgroup specified by this optional parameter. - The default value `dft_input` is used as the subgroup name. - * `symmcorr_subgrp`: In this subgroup we store all the data for applying the symmetry - operations in the DMFT loop. The default value is `dft_symmcorr_input`. - * `repacking`: If true, and the hdf5 file already exists, the system command :program:`h5repack` - is invoked. This command ensures a minimal file size of the hdf5 - file. The default value is `False`. If you wish to use this, ensure - that :program:`h5repack` is in your path variable! +========================= ============================ =========================================================================== +Name Type, Default Meaning +========================= ============================ =========================================================================== +filename String Material being studied, corresponding to the :program:`Wien2k` file names. + The constructor stores the data in the hdf5 archive :file:`material_of_interest.h5`. +dft_subgrp String, dft_input hdf5 subgroup containing required DFT data +symmcorr_subgrp String, dft_symmcorr_input hdf5 subgroup containing all necessary data to apply + the symmetry operations in the DMFT loop +repacking Boolean, False Does the hdf5 file already exist and should the :program:`h5repack` be + invoked to ensures a minimal archive file size? + Note that the :program:`h5repack` must be in your path variable! +========================= ============================ =========================================================================== After initialising the interface module, we can now convert the input text files into the hdf5 archive by:: @@ -70,8 +74,12 @@ of :program:`Wien2k`, you have to use:: This reads the files :file:`material_of_interest.parproj` and :file:`material_of_interest.sympar`. Again, there are two optional parameters - * `parproj_subgrp`: The subgroup for partial projectors data. The default value is `dft_parproj_input`. - * `symmpar_subgrp`: The subgroup for symmetry operations data. The default value is `dft_symmpar_input`. +========================= ============================ =========================================================================== +Name Type, Default Meaning +========================= ============================ =========================================================================== +parproj_subgrp String, dft_parproj_input hdf5 subgroup containing partial projectors data. +symmpar_subgrp String, dft_symmpar_input hdf5 subgroup containing symmetry operations data. +========================= ============================ =========================================================================== Another routine of the class allows to read the input for plotting the momentum-resolved spectral function. It is done by:: diff --git a/doc/reference/h5structure.rst b/doc/reference/h5structure.rst index 982edf75..5fd3bbf2 100644 --- a/doc/reference/h5structure.rst +++ b/doc/reference/h5structure.rst @@ -9,7 +9,7 @@ All the data is stored using the hdf5 standard, as described also in the documen hdf5 data format ---------------- -In order to be used with the DMFT routines, the following data needs to be provided in the hdf5 file. It contains a lot of information in order to perform DMFT calculations for all kinds of situations, e.g. d-p Hamiltonians, more than one correlated atomic shell, or using symmetry operations for the k-summation. We store all data in subgroups of the hdf5 arxive: +In order to be used with the DMFT routines, the following data needs to be provided in the hdf5 file. It contains a lot of information in order to perform DMFT calculations for all kinds of situations, e.g. d-p Hamiltonians, more than one correlated atomic shell, or using symmetry operations for the k-summation. We store all data in subgroups of the hdf5 archive: :program:`Main data`: There needs to be one subgroup for the main data of the calculation. The default name of this group is `dft_input`. Its contents are