https://wiki.yambo-code.eu/wiki/api.php?action=feedcontributions&feedformat=atom&user=NicolaspallanzaniThe Yambo Project - User contributions [en]2026-05-17T14:34:46ZUser contributionsMediaWiki 1.39.8https://wiki.yambo-code.eu/wiki/index.php?title=Calculating_optical_spectra_including_excitonic_effects:_a_step-by-step_guide&diff=8798Calculating optical spectra including excitonic effects: a step-by-step guide2025-05-21T14:13:25Z<p>Nicolaspallanzani: /* Links */</p>
<hr />
<div>This tutorial guides you through the workflow of a calculation of the optical spectrum of a given material by solving the Bethe-Salpeter equation.<br />
Specifically, we will use [[Bulk material: h-BN|bulk h-BN]] as an example.<br />
<br />
[[File:HBN-bulk-3x3-annotated.png|x200px|center|Atomic structure of bulk hBN]]<br />
<br />
Before starting, you need to obtain the tarballs for hBN. See instructions on the [[Tutorials|main tutorials page]].<br />
<br />
The target quantity in a Bethe-Salpeter calculation is the macroscopic dielectric matrix &epsilon;<sub>M</sub>. The following quantities/steps are needed to obtain &epsilon;<sub>M</sub>: <br />
<br />
[[File:Scheme1b.png|500px|center|BSE calculation scheme]]<br />
<br />
The optical absorption spectrum corresponds to Im&epsilon;<sub>M</sub>(&omega;). Following this scheme we go through the flow of a calculation:<br />
__TOC__<br />
<br />
===Step 1: Static screening===<br />
Use the ''SAVE'' folders that are already provided and type:<br />
$ cd YAMBO_TUTORIALS/hBN/YAMBO<br />
<br />
Follow the '''[[Static screening]]''' module and then '''return to this tutorial '''<br />
<br />
===Step 2: Bethe-Salpeter kernel===<br />
Follow the module on '''[[Bethe-Salpeter kernel]]''' and '''return to this tutorial''' <br />
<br />
===Step 3: Diagonalisation of the excitonic Hamiltonian ===<br />
This is the step in which you obtain the spectra. Mathematically this implies solving a large eigenvalue problem. In this tutorial, we diagonalise the whole Bethe-Salpeter matrix, but there are other numerical approaches available in Yambo. The difference between these approaches and when they should be used is the object of [[BSE solvers overview|one of the next tutorials]]. <br />
<br />
Follow the module on '''[[Bethe-Salpeter solver: diagonalization]]''' then '''return to this tutorial'''<br />
<br />
===Step 4: Include previous quasiparticle (GW) results ===<br />
In Step 3, we included the quasiparticle corrections to the Kohn-sham energies as a scissor operator. An alternative is to use the results from a previous run of Yambo.<br />
<br />
Follow the module on '''[[Bethe-Salpeter on top of quasiparticle energies]]''' and '''return to this tutorial'''<br />
<br />
==Links==<br />
* Back to [[Modena 2025]]<br />
* Back to [[Rome 2023#Tutorials]]<br />
* [[Modules|Back to technical modules menu]]<br />
* [[Tutorials|Back to tutorials menu]]<br />
<br />
<!-- <br />
= Calculating the effective two-particle Hamiltonian = <br />
<br />
This first part calculates and stores the two-particle Hamiltonian matrix elements:<br />
[[File:BSE1-Eq1.png|none|x50px]]<br />
where ''vc'''''k''' indicates the pair of quasiparticle states ''v'''''k''' and ''c'''''k'''.<br />
The first term on the RHS is the quasiparticle energy differences (diagonal only). The second term is the kernel which is the sum of the electron-hole exchange part ''V'' (which stems from the Hartree potential) and the electron-hole attraction part ''W'' (which stems from the screened exchange potential). The kernel both shifts (diagonal contributions) and couples (off-diagonal contributions) the quasiparticle energy differences. <br />
<br />
We start the calculation by running the [[Initialization|initialization step]] (i.e. invoke yambo from the command line in the directory containing the relevant SAVE directory).<br />
<br />
== Step1: Calculation of the static dielectric screening.==<br />
<br />
Next, to calculate the correlation part of the kernel ''W'' we need the static dielectric screening. This is a calculation of the linear response of the system analogous to the calculation of the [[RPA/IP]] dielectric function. One important difference is that here we consider the static dielectric function. <br />
[[File:BSE1-Eq2.png|none|x50px]]<br />
<br />
<br />
Start by [[Input file generation|generating the input]] by invoking yambo with the option "-b" from the command line:<br />
<br />
$ yambo -b -F 01_3D_BSE_screening.in<br />
<br />
The input opens in the standard editor. Similarly to the other linear response calculations the relevant input variables to be changed are: <br />
<br />
% [[Variables#BndsRnXs|BndsRnXs]]<br />
1 | 40 | <br />
%<br />
[[Variables#NGsBlkXs|NGsBlkXs]]= 4 Ry<br />
<br />
The first variable gives how many bands are included in the sum to calculate the static response function. The second is a cutoff for the dimension of the static dielectric matrix.<br />
<br />
In the [[How to choose the input parameters|next tutorial]] you will see how to choose these two parameters. Another relevant input parameter to change is<br />
<br />
% [[Variables#LongDrXs|LongDrXs]]<br />
1.000 | 1.000| 1.000<br />
%<br />
<br />
so that the perturbing electric field has component in each direction.<br />
<br />
Run the calculation by invoking yambo:<br />
$ yambo -F 01_3D_BSE_screening.in -J 3D_BSE <br />
<br />
In the log (l_em1s) of the calculation you can see that after calculating the dipole matrix elements, for each q vector yambo calculates the IP response function and by inversion the RPA response function <br />
<br />
<02s> Xo@q[1] |########################################| [100%] --(E) --(X)<br />
<02s> X@q[1] |########################################| [100%] --(E) --(X)<br />
<br />
In the report, r_em1s, the details of the calculations are reported under the 5th section<br />
<br />
[05] Static Dielectric Matrix<br />
=============================<br />
<br />
This calculation does not produce any human readable output, but both the dipole matrix elements and the static screening dielectric function are saved in a database in the 3D_BSE directory:<br />
<br />
3D_BSE/ndb.dip_iR_and_P<br />
3D_BSE/ndb.em1s<br />
<br />
which are needed and read by the following yambo runlevels.<br />
<br />
== Step2: Calculation of matrix elements of the BSE kernel ==<br />
<br />
You have now all ingredients to calculate the kernel <br />
<br />
[[File:BSE1_Eq3.png|none|x100px]]<br />
<br />
<br />
(and thus the two-particle Hamiltonian matrix elements).<br />
<br />
Start by generating the input by invoking yambo with the option "-o b -k bse -V qp" from the command line:<br />
<br />
$ yambo -o b -k bse -V qp -F 02_3D_BSE_kernel.in<br />
<br />
The input opens in the standard editor. The relevant input parameters to be changed are <br />
<br />
[[Variables#BSENGexx|BSENGexx]] = 30 Ry<br />
[[Variables#BSENGBlk|BSENGBlk]] = 4 Ry<br />
% [[Variables#BSEBands|BSEBands]]<br />
6 | 10 | <br />
%<br />
The first two are the cutoff for the summations on the reciprocal lattice vectors which appear in the expressions for ''V'' (BSENGexx) and ''W'' (BSENGBlk) here above. <br />
<br />
The third parameter gives the range of quasiparticle states (their band index) that define the basis of quasiparticle pairs that we need to describe the excitons (in the energy range of interest).<br />
For example since we have 8 occupied bands, here we consider the pairs of bands: ''6-9'', ''6-10'', ''7-9'', ''7-10'', ''8-9'', ''8-10'' (those are 6 pairs of bands = 2 valence times 3 conduction bands). <br />
<br />
For each of those pairs we then consider all '''k''' points in the Brillouin zone available from the DFT calculations. Since we have a ''6 x 6 x 2'' grid, this amounts to 72 '''k''' points in the Brillouin zone. <br />
<br />
Then finally we are using a basis of ''6 x 72 = 432'' ''vc'''''k''' pairs to represent the excitons of the system. <br />
<br />
The values for these 3 parameters are chosen from convergence studies, as discussed in the [[How to choose the input parameters|next tutorial]].<br />
<br />
Another parameter to modify is<br />
% [[Variables#KfnQP_E|KfnQP_E]] <br />
1.440000 | 1.000000 | 1.000000 |<br />
%<br />
This gives the quasiparticle corrections to the Kohn-Sham eigenvalues and is deduced either from experiment or previous [[How to obtain the quasi-particle band structure of a bulk material: h-BN|GW calculations]]. <br />
The corrections consist in a shift (first value) of the conduction bands in eV and renormalization of the conduction and valence bandwidths (second and third value). <br />
Alternatively we can directly input corrections calculated from a previous GW calculation as we will learn later in this tutorial.<br />
<br />
Run the calculation by invoking yambo in the command line:<br />
$ yambo -F 02_3D_BSE_kernel.in -J 3D_BSE <br />
In the log (either in standard output or in l_optics_bse_bsk), after various setup/loading, the kernel is calculated: <br />
<br />
<01s> [05.04.03] Kernel loop<br />
<02s> Kernel |########################################| [100%] --(E) --(X)<br />
<br />
In the report r_optics_bse_bsk the information relative to this runlevel are reported under the section:<br />
<br />
<br />
[05] Response Functions in Transition space<br />
===========================================<br />
<br />
<br />
Take some time to inspect the log and the report. For example try to find where the input parameters are reported, the dimension of the 2-particle hamiltonian and if these match your expectations.<br />
<br />
This run does not produce any human readable output. The kernel is stored in a database in the 3D_BSE directory<br />
<br />
3D_BSE/ndb.BS_Q1<br />
<br />
= Obtaining the optical spectrum from the two-particle Hamiltonian =<br />
The macroscopic dielectric function (from which the absorption and EEL spectra can be computed) is obtained from the eigenvalues ''E''<sub>&lambda;</sub> (excitonic energies) and eigenvectors A<sup>&lambda;</sup><sub>''cv'''''k'''</sub> (exciton composition in terms of electron-hole pairs) of the two-particle Hamiltonian:<br />
<br />
[[File:BSE1-Eq4.png|none|x50px]]<br />
<br />
To get the two-particle Hamiltonian eigensolutions you can either <br />
<br />
(1) diagonalize the full Hamiltonian (diagonalization solver) <br />
<br />
(2) use the subspace iterative [https://en.wikipedia.org/wiki/Lanczos_algorithm | Lanczos algorithm] and by-pass diagonalization with the Haydock approach<ref>R. Haydock, in<br />
''Solid State Phys.'', '''35''' 215 (1980)<br />
edited by H. Ehrenfest, F. Seitz, and D. Turnbull, Academic Press</ref> (Lanczos-Haydock solver)<br />
<br />
Both approaches are detailed here below.<br />
<br />
== Diagonalization solver ==<br />
<br />
Invoke yambo with the "-y d" option in the command line:<br />
<br />
$ yambo -y d -F 03_3D_BSE_diago_solver.in<br />
<br />
The input is open in the editor. The input variable to be changed are <br />
% [[Variables#BEnRange|BEnRange]]<br />
2.00000 | 8.00000 | eV <br />
%<br />
[[Variables#BEnSteps|BEnSteps]]= 200 <br />
<br />
which define 200 evenly spaced points between 2 and 8 eV at which the spectrum is calculated (&omega; in the equation for the macroscopic dielectric function),<br />
<br />
% [[Variables#BDmRange|BDmRange]]<br />
0.10000 | 0.10000 | eV <br />
%<br />
<br />
which defines the spectral broadening (Lorentzian model), <br />
<br />
% [[Variables#BLongDir|BLongDir]]<br />
1.000000 | 1.000000 | 0.000000 | <br />
%<br />
<br />
which defines the direction of the perturbing electric field (in this case the in-plane direction).<br />
<br />
Run yambo: <br />
$ yambo -F 03_3D_BSE_diago_solver.in -J 3D_BSE <br />
In the log (either in standard output or in l-3d_BSE_optics_bse_bsk_bss), after various setup/loading, the BSE is diagonalized using the linked linear algebra libraries: <br />
<01s> [06] BSE solver(s)<br />
<01s> [LA] SERIAL linear algebra<br />
<01s> [06.01] Diagonalization solver<br />
<01s> BSK diagonalize |########################################| [100%] --(E) --(X)<br />
<01s> EPS residuals |########################################| [100%] --(E) --(X)<br />
<01s> BSK epsilon |########################################| [100%] --(E) --(X)<br />
The report r-3d_BSE_optics_bse_bsk_bss contains information relative to this runlevel in section 6:<br />
<br />
[06] BSE solver(s)<br />
==================<br />
<br />
Take some time to inspect the log and the report to check the consistency with the input variables. This run produces a new database in the 3D_BSE directory<br />
3D_BSE/ndb.BS_diago_Q01<br />
So if you need the spectrum on a different energy range, direction, with a different broadening or on more points the diagonalization is not repeated, just the spectrum is recalculated.<br />
<br />
This run produces as well human readable files (o-*). Specifically o-3D_BSE.eps_q1_diago_bse contains the real and imaginary part of the macroscopic dielectric function <br />
<br />
$ less o-3D_BSE.eps_q1_diago_bse <br />
...<br />
#<br />
# E/ev[1] EPS-Im[2] EPS-Re[3] EPSo-Im[4] EPSo-Re[5]<br />
#<br />
2.00000 0.16162 5.83681 0.04959 4.14127<br />
2.03015 0.16787 5.88612 0.05090 4.15638<br />
...<br />
<br />
which is in the format <br />
Energy in eV | Imaginary part BSE | Real part BSE |Imaginary part IPA | Real part IPA | <br />
<br />
where real and imaginary parts refer to the macroscopic dielectric function. The imaginary part corresponds to the optical absorption. The latter (column 2) can be plotted versus the photon energy (column 1) and compared with the independent particle approximation (IPA, column 4), e.g.: <br />
<br />
$ gnuplot<br />
...<br />
plot 'o-3D_BSE.eps_q1_diago_bse' u 1:2 w l t 'BSE', 'o-3D_BSE.eps_q1_diago_bse' u 1:4 w l t 'IPA'<br />
<br />
[[file:03_bse_diago.png |none|600px]]<br />
The addition of the kernel has the effect to red-shift the spectrum onset and to redistribute the oscillator strengths. Note that the convergence with respect to k-points smooths out the low energy peaks in the IPA (which are an artifact of poor convergence with k-points producing an artificial confinement) to give the shoulder corresponding to the van Hove singularity in the band structure. On the other hand the low energy peak in the BSE is genuine and it is the signature of a bound exciton.<br />
<br />
== Lanczos-Haydock solver ==<br />
<br />
You can avoid the full matrix diagonalization (which rapidly become expensive as it scales as N<sup>3</sup>) by using the Lanczos-Haydock solver mentioned above. While for small matrices these two methods have similar computational cost, for matrices of the size 10000 by 10000 and larger, the Haydock solver is remarkably faster. The drawback is that excitonic functions cannot be calculated.<br />
Within the Lanczos-Haydock approach the macroscopic dielectric function is rewritten as continued fraction<ref>L. X. Benedict and E. L. Shirley, Phys. Rev. B '''59''', 5441 (1999)</ref><br />
<br />
[[file:BSE1-Eq5.png|none|x100px]]<br />
<br />
where ''a'' 's and ''b'' 's result from the [https://en.wikipedia.org/wiki/Lanczos_algorithm#Lanczos_method| Lanczos iterative algorithm]. <br />
<br />
To use the Lanczos-Haydock solver invoke yambo with "-y h" option in the command line:<br />
<br />
$ yambo -y h -F 03_3D_BSE_haydock_solver.in<br />
Beside the same input parameters defined for the diagonalization solver, the parameter<br />
[[Variables#BSHayTrs|BSHayTrs]]= -0.02000 <br />
defines the threshold accuracy for the Lanczos-Haydock iterative process: the calculation stops when the difference between two consecutive calculated spectra is smaller than the absolute value of the threshold. <br />
The minus sign indicates that the average difference over the specified energy range is considered (i.e. that means that cancellations of error may occur) as opposed to the maximum absolute difference over the specified energy range (plus sign). For the moment we leave this variable unchanged. This parameter ultimately determines the terms are included in the continued fraction here above. Later we explore how this variable influences the final result. <br />
<br />
Invoke yambo to run the calculation:<br />
$ yambo -F 03_3D_BSE_haydock_solver.in -J "3D_BSE-low,3D_BSE" <br />
This outputs the following log:<br />
...<br />
<01s> [06] BSE solver(s)<br />
<01s> [06.01] Haydock solver<br />
<01s> [Haydock] Iteration 1<br />
<03s> [Haydock] Iteration 21 Accuracy : 0.01647| -0.02000<br />
...<br />
The Lanczos-Haydock iterative procedure converged to the desired accuracy in 21 iterations.<br />
<br />
This runs only produces human readable files. That means that if you changes the input parameters (such as the broadening or the energy range) the Lanczos-Haydock procedure has to be repeated. <br />
Among the human readable files, o-3D_BSE-low.eps_q1_haydock_bse contains the real and imaginary part of the macroscopic dielectric function:<br />
$ less o-3D_BSE-low.eps_q1_haydock_bse<br />
...<br />
#<br />
# E/ev[1] EPS-Im[2] EPS-Re[3] EPSo-Im[4] EPSo-Re[5] EPS`-Im[6] EPS`-Re[7]<br />
#<br />
2.00000 0.16089 5.81293 0.04945 4.12727 0.16089 5.81293<br />
2.03015 0.16711 5.86203 0.05076 4.14234 0.16711 5.86203<br />
...<br />
This file has a slightly different data structure with respect to the diagonalization solver:<br />
Energy in eV | Imaginary part BSE | Real part BSE |Imaginary part IPA | Real part IPA |Imaginary part BSE (it-1) | Real part BSE (it-1)|<br />
<br />
We can plot the second and sixth columns and compare with the result from diagonalization:<br />
$gnuplot<br />
...<br />
plot 'o-3D_BSE.eps_q1_diago_bse' u 1:2 w l t 'Diagonalization', 'o-3D_BSE-low.eps_q1_haydock_bse' u 1:2 w l t 'Haydock (27 its)', 'o-3D_BSE-low.eps_q1_haydock_bse' u 1:6 w l t 'Haydock (26 its)'<br />
[[file:03_bse_haydock.png|none|600px]]<br />
Except for the peak at higher energy, the results on this scale are identical to those obtained via the diagonalization solver. By comparing the results for the Lanczos-Haydock solver at 27 and 26 iterations, it is clear that the difference with the diagonalization results can be eliminated by lowering the threshold for the iterative process.<br />
<br />
Repeat now the calculation by changing the input variable:<br />
[[Variables#BSHayTrs|BSHayTrs]]= 0.02000 <br />
which enforces a stricter condition on the convergence of the iterative process (see above)<br />
<br />
Running yambo: <br />
$ yambo -F 03_3D_BSE_haydock_solver.in -J "3D_BSE-high,3D_BSE" <br />
outputs the following log <br />
...<br />
<01s> [06] BSE solver(s)<br />
<01s> [06.01] Haydock solver<br />
<01s> [Haydock] Iteration 1<br />
<06s> [Haydock] Iteration 45 Accuracy : 0.0098| 0.02000<br />
...<br />
Now 45 iterations, rather than 21, were needed to reach the desired accuracy.<br />
By plotting these results:<br />
$ gnuplot<br />
plot 'o-3D_BSE.eps_q1_diago_bse' u 1:2 w l ls 1 t 'Diagonalization', 'o-3D_BSE-high.eps_q1_haydock_bse' u 1:2 w l ls 2 t 'Haydock (high)', 'o-3D_BSE-low.eps_q1_haydock_bse' u 1:2 w l ls 3 t 'Haydock (low)'<br />
[[file:03_bse_haydock_high.png|none|600px]]<br />
Which shows that the Lanczos-Haydock solver with the stricter convergence criterion and the diagonalization solver are identical on this scale.<br />
<br />
=Some more advanced options =<br />
<br />
==Reading the QP corrections from a previous ''GW'' calculation==<br />
In the above calculation we have used a simple scissor operator to correct the Kohn-Sam DFT energies. In this part we see how we can instead take the corrections from a previous Yambo Gw calculation.<br />
We create and edit the input. This time instead of proceeding in three steps as before, we create one input performing all three steps:<br />
$yambo -o b -k sex -y d -V qp -F Ins/05_3D_QP_BSE.in<br />
We set all parameters as in the previous calculation, except for the part regarding the QP correction:<br />
[[Variables#KfnQPdb|KfnQPdb]]= "E < 3D_QP_BSE/ndb.QP" # [EXTQP BSK BSS] Database<br />
[[Variables#KfnQP_N|KfnQP_N]]= 1 # [EXTQP BSK BSS] Interpolation neighbours<br />
% [[Variables#KfnQP_E|KfnQP_E]]<br />
0.000000 | 1.000000 | 1.000000 | # [EXTQP BSK BSS] E parameters (c/v) eV|adim|adim<br />
%<br />
Instead of setting the values for the scissor, we give the path to a database (3D_QP_BSE/ndb.QP) which contains the QP corrections. This has been created by running a GW calculation as in the [[How to obtain the quasi-particle band structure of a bulk material: h-BN |GW tutorial]].<br />
Run Yambo:<br />
$ yambo -F Ins/05_3D_QP_BSE.in -J "3D_QP_BSE,3D_BSE"<br />
This produces the following log in the standard output. Note Section 4 (regarding external QP corrections to the kernel):<br />
<01s> [04.01] External QP corrections (K)<br />
<01s> [QP@K] E<3D_QP_BSE/ndb.QP[ PPA XG:39 Xb:1 40 Scb:1 40]<br />
<01s> [QP] Kpts covered exactly [o/o]: 100.0000<br />
This tells you that the file was found, read correctly and that the '''k''' points found in the file matched the ones you are using for the current calculation (otherwise interpolation would be needed).<br />
It is crucial to check that the file has been read, since if not Yambo gives a warning but continues the calculation (with no QP corrections at all!).<br />
As in the previous calculation the final results of the calculation are the files with the spectral functions. Let's compare the results for the optical absorption spectrum with those obtained previously with a simple scissor:<br />
$ gnuplot<br />
...<br />
plot 'o-3D_QP_BSE.eps_q1_diago_bse' u 1:2 w l t 'Explicit QP', 'o-3D_BSE.eps_q1_diago_bse' u 1:2 w l t 'Scissor' <br />
[[File:03 bse diago qp.png|none|600px]]<br />
It is clear that this makes a difference in the peak distribution and intensity. Note that beside a simple shift you can renormalise as well the bandwidth of the valence and conduction bands in KfnQP_E (respectively the third and second value). You can try as an exercise to set up a new calculation using e.g. 1.440000 | 1.200000 | 0.900000 | for KfnQP_E.<br />
<br />
<br />
=References =<br />
<references /><br />
--></div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=How_to_choose_the_input_parameters&diff=8797How to choose the input parameters2025-05-21T14:13:03Z<p>Nicolaspallanzani: /* Links */</p>
<hr />
<div>In a [[Calculating optical spectra including excitonic effects: a step-by-step guide|previous tutorial]], you have been guided step-by-step through the calculations of the optical spectrum of bulk ''h-BN'' by solving the Bethe-Salpeter equation. The values for the relevant input parameters have then been given to you.<br />
<br />
In this tutorial you will learn how to choose these parameters which are related either to the truncation of infinite sums or to the approximations of infinitesimal with small, but finite quantities. A wrong choice of these parameters can lead to inaccurate or even physically wrong results. One needs to run a series of calculations by changing the parameters until the results are ''converged'', meaning they are changing by what you consider a negligible amount. This is a tedious yet essential part of determining the optical properties of a system.<br />
<br />
Note that all the operations described below can be automated. A flexible python-based interface to yambo, [[First steps in Yambopy|yambopy]], can be used for this purpose. It is worth however to go at least once through the pain of a 'by-hand' convergence study so to better understand the automated process.<br />
<br />
==Before starting==<br />
<br />
Have completed (or be familiar with the content of) the following tutorials:<br />
* [[First steps: a walk through from DFT to optical properties]]<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide]]<br />
<br />
==Background==<br />
<br />
Coming back to the scheme to calculate the macroscopic dielectric matrix within Bethe-Salpeter (BS), the list of the parameters that have to be determined by convergence studies are:<br />
<br />
[[File:Scheme2.png|500px|center|convergence parameters]]<br />
<br />
This provides as well a scheme for a full convergence study:<br />
* first the parameters for the screening have to be determined, <br />
* then the parameters for the BS kernel, and <br />
* finally the convergence with respect to the choice of the k-mesh needs to performed. <br />
<br />
==Convergence of the static screening==<br />
The parameters that need to be converged can be understood by looking at the equations:<br />
[[File:Yambo-CH5.png|none|x30px|Yambo tutorial image]]<br />
where ''&chi;<sub>GG'</sub>'' is given by<br />
[[File:Dyson_rpa.png|none|x50px|Yambo tutorial image]]<br />
<br />
* <code>[[Variables#NGsBlkXs|NGsBlkXs]]</code> : The dimension of the microscopic inverse matrix, related to [[Local fields]]<br />
* <code>[[Variables#BndsRnXs|BndsRnXs]]</code> : The sum on bands in the independent particle &chi;<sup>0</sup><sub>GG'</sub><br />
<br />
Furthermore as shown in [[Optics at the independent particle level#Energy cutoff|this tutorial]] one can reduce the value of <br />
* <code>[[Variables#FFTGvecs|FFTGvecs]]</code><br />
since generally, fewer G-vectors are needed than what are needed in DFT calculations. This can be critical for large calculations, or for supercells with a lot of vacuum.<br />
Remember that the latter parameter appears only when the input is generated specifying the verbosity level <code>-V RL</code><br />
<br />
The convergence for the static screening then is similar to the convergence of other response functions and for the plasmon-pole in [[How to obtain the quasi-particle band structure of a bulk material: h-BN|GW calculations]] and won't be covered here. Note in fact that you can re-use the database obtained (and converged) from a previous screening calculation as long as the same k-points are used.<br />
<br />
==Convergence of the macroscopic dielectric function==<br />
In the expression for the macroscopic dielectric function <br />
[[File:BSE1-Eq4.png|none|x50px]]<br />
<br />
depends on the summation over the pair of quasiparticle states ''vc'''''k'''.<br />
<br />
* <code>[[Variables#BSEBands|BSEBands]]</code> : defines the ''vc'' pairs.<br />
* the k-point mesh of the DFT calculations defines the '''k''' <br />
<br />
Basically we need a large enough basis of transitions (pair of quasiparticle states) to correctly describe the excitons (in the energy region of interest).<br />
<br />
Furthermore, in the kernel components<br />
<br />
[[File:BSE1_Eq3.png|none|x100px]]<br />
<br />
the summations over '''G''' vectors appear. These corresponds to two parameters:<br />
<br />
* <code>[[Variables#BSENGblk|BSENGblk]]</code>: defines the screened interaction block size (double sum in ''W''), related to the electron-hole attraction.<br />
* <code>[[Variables#BSENGexx|BSENGexx]]</code>: defines the components of Hartree potential (the sum in ''V''), related to local fields.<br />
<br />
In the following we will see how the spectrum depends on these parameters.<br />
<br />
===Prepare the common databases===<br />
<br />
Enter the <code>hBN</code> directory (containing a 6x6x2 k-grid SAVE) and run the initialization if you didn't do it before. <br />
<br />
> cd YAMBO_TUTORIALS/hBN/YAMBO<br />
<br />
For all the calculations in this sessions you can fix the screening parameters, and thus calculate the screening once for all.<br />
Following the scheme we learned in previous tutorial:<br />
<br />
* Create the input for calculating the screening:<br />
<br />
> yambo -F 02_screening.in -X s<br />
<br />
* Modify the input as follows<br />
<br />
NGsBlkXs = 4 Ry<br />
%BndsRnXs<br />
1 | 40 |<br />
%<br />
%LongDrXS<br />
1.000 | 1.000 | 1.000|<br />
%<br />
<br />
* Run the calculation for the screening<br />
<br />
> yambo -F 02_screening.in <br />
<br />
As we do not specify a particular prefix, the screening databases <code>ndb.dip_iR_and_P, ndb.em1s</code> are saved in the <code>SAVE</code> folder and visible to all the subsequent jobs you will launch is this directory.<br />
<br />
===Convergence with the cut-off for reciprocal lattice vectors sums=== <br />
As next step, create the input for calculating the macroscopic dielectric function:<br />
> yambo -F 03_bse.in -o b -k sex -y d -V qp<br />
Which combines the BS kernel + BS solver (diagonalization) runlevels<br />
* Modify the input as follows<br />
[[Variables#BSENGexx|BSENGexx]] = 30 Ry<br />
[[Variables#BSENGBlk|BSENGBlk]] = 4 Ry<br />
% [[Variables#BSEBands|BSEBands]]<br />
6 | 10 | <br />
%<br />
% [[Variables#BEnRange|BEnRange]]<br />
2.00000 | 8.00000 | eV <br />
%<br />
[[Variables#BEnSteps|BEnSteps]]= 100 <br />
% [[Variables#BDmRange|BDmRange]]<br />
0.10000 | 0.10000 | eV <br />
%<br />
% [[Variables#BLongDir|BLongDir]]<br />
1.000000 | 1.000000 | 0.000000 | <br />
%<br />
% [[Variables#KfnQP_E|KfnQP_E]] <br />
1.440000 | 1.000000 | 1.000000 |<br />
%<br />
* Launch the calculation:<br />
> yambo -F 03_bse.in -J 3D_4Ry_GBlk<br />
This produces the file with the optical spectrum <code>o-3D_4Ry_GBlk.eps_q1_diago_bse</code>.<br />
<br />
* Open the <code>03_bse.in</code> in an editor and changes:<br />
[[Variables#BSENGBlk|BSENGBlk]] = '''3 Ry'''<br />
while leaving the rest untouched.<br />
* Launch the calculation:<br />
> yambo -F 03_bse.in -J 3D_3Ry_GBlk<br />
This produces the file with the optical spectrum <code>o-3D_3Ry_GBlk.eps_q1_diago_bse</code>. <br />
<br />
* Repeat this operation for <code>BSENGBlk= '''2 Ry'''</code> and <code>BSENGBlk= '''1 Ry'''</code>. Remember to change the prefix correspondingly so that you can later on identify the job, e.g. <code>-J 3D_2Ry_GBlk</code> for <code>BSENGBlk='''2 Ry'''</code> etc.<br />
<br />
* Finally plot the obtained optical spectra:<br />
> gnuplot<br />
plot 'o-3D_4Ry_GBlk.eps_q1_diago_bse' w l t '4 Ry','o-3D_3Ry_GBlk.eps_q1_diago_bse' w l t '3 Ry', 'o-3D_2Ry_GBlk.eps_q1_diago_bse' w l t '2 Ry', 'o-3D_1Ry_GBlk.eps_q1_diago_bse' w l t '1 Ry'<br />
<br />
[[File:03 bse conv GBlk.png|500px|center|convergence with Gblk ]]<br />
<br />
This shows that <code>BSENGBlk= '''2 Ry'''</code> gives already a results close to convergence and we can confidently lower <code>BSENGBlk</code> to 2 or 3 Ry. <br />
<br />
* Repeat now the same procedure with <code>BSENGexx</code>. Change the value to 10 Ry and 20 Ry. Remember to change the prefix correspondingly so that you can later on identify the job, e.g. <code>-J 3D_10Ry_Gexx</code> for <code>BSENGexx= '''10 Ry'''</code> etc., and remember to keep the value of <code>BSENGBlk</code> the same throughout these calculations.<br />
<br />
* Finally plot the obtained optical spectra:<br />
> gnuplot<br />
plot 'o-3D_4Ry_GBlk.eps_q1_diago_bse' w l t '30 Ry' ls 1,'o-3D_20Ry_Gexx.eps_q1_diago_bse' w l t '20 Ry', 'o-3D_10Ry_Gexx.eps_q1_diago_bse' w l t '10 Ry'<br />
<br />
[[File:03 bse conv Gexx.png|500px|center|convergence with Gexx ]]<br />
<br />
The plot shows that already with <code>BSENGexx= '''10 Ry'''</code> the spectrum is converged and the cut-off can be lowered to this value.<br />
<br />
===Convergence with the BS bands=== <br />
You can now repeat the procedure above keeping fixed all parameters to their original values except for<br />
% BSEBands<br />
6 | 10 | <br />
%<br />
Typically only the bands which are close to the Fermi energies contributes to the spectrum. If the energy separation between two bands is much larger than the spectral energy range, you can assume the corresponding transitions are not contributing to the spectra. <br />
<br />
* Repeat then the calculation for the optical spectrum using the following band ranges: <br />
''7-10'', ''8-10'', ''6-9'', ''7-9'' and ''8-9''. <br />
<br />
When launching the job remember to identify your job with a recognizable name, e.g. <code>-J 3D_7-9_BND</code> for the ''7-9'' range. <br />
<br />
* Plot the optical spectra obtained from the different runs:<br />
> gnuplot<br />
plot 'o-3D_4Ry_GBlk.eps_q1_diago_bse' w l t '6-10 Bands','o-3D_7-10_BND.eps_q1_diago_bse' w l t '7-10 Bands', 'o-3D_8-10_BND.eps_q1_diago_bse' w l t '8-10 Bands'<br />
plot 'o-3D_4Ry_GBlk.eps_q1_diago_bse' w l t '6-10 Bands','o-3D_6-9_BND.eps_q1_diago_bse' w l t '6-9 Bands', 'o-3D_7-9_BND.eps_q1_diago_bse' w l t '7-9 Bands', 'o-3D_8-9_BND.eps_q1_diago_bse' w l t '8-9 Bands'<br />
<br />
[[File:03 band convergence 1.png|500px|left|Band convergence]] [[File:03 band convergence2.png|500px|center|Band convergence 2]]<br />
<br />
The plots show that we need to include valence bands from at least 6-7 (those bands are degenerate at several high symmetry points of the Brillouin zone) and conduction at least up to band 10.<br />
To see if this is sufficient you can try to include more bands.<br />
<br />
For example you can prepare and run calculations with the following bands ranges: ''1-12'', ''4-12'', ''4-14'' and plot the results: <br />
> gnuplot<br />
plot 'o-3D_4Ry_GBlk.eps_q1_diago_bse' w l t '6-10 Bands','o-3D_4-12_BND.eps_q1_diago_bse' w l t '4-12 Bands', 'o-3D_4-14_BND.eps_q1_diago_bse' w l t '4-14 Bands', 'o-3D_1-12_BND.eps_q1_diago_bse' w l t '1-12 Bands' ls 4<br />
<br />
[[File:03 bse conv Bnds1.png|500px|center|convergence with Bnds]]<br />
<br />
The plot is showing that the spectrum changes only marginally when adding those bands.<br />
<br />
==Convergence with the k-point mesh==<br />
As final step you need to study the dependence on the '''k''' mesh. This parameter cannot be changed in yambo. For each '''k''' mesh you need to run a separate non-self consistent DFT calculation (on top of a converged self-consistent one) and generate the corresponding SAVE folders. Be careful to change '''only''' the '''k''' mesh.<br />
<br />
For this exercise the SAVE databases for different meshes were generated beforehand in the [http://www.yambo-code.org/educational/tutorials/files/hBN-convergence-kpoints.tar.gz hBN-convergence-kpoints.tar.gz] tarball and are contained in the corresponding folders:<br />
> pwd<br />
YAMBO_TUTORIALS/hBN-convergence-kpoints/YAMBO<br />
> ls<br />
9x9x3 12x12x4 15x15x5 18x18x6<br />
<br />
By now you should be familiar with the process:<br />
<br />
* Enter the 9x9x3 directory <br />
* Run the initialization <br />
* Create the input for calculating the screening:<br />
> yambo -F 02_screening.in -J 3D_993 -X s<br />
* Modify the input as follows<br />
[[Variables#NGsBlkXs|NGsBlkXs]] = 4 Ry<br />
%[[Variables#BndsRnXs|BndsRnXs]]<br />
1 | 40 |<br />
%<br />
%[[Variables#LongDrXS|LongDrXS]]<br />
1.000 | 1.000 | 1.000|<br />
%<br />
* Run the calculation for the screening<br />
> yambo -F 02_screening.in -J 3D_993<br />
* Create the input for calculating the macroscopic dielectric function:<br />
> yambo -F 03_bse.in -J 3D_993 -o b -k sex -y h -V qp<br />
Which combines the BS kernel + BS solver (Lanczos-Haydock) runlevels<br />
* Modify the input as follows<br />
[[Variables#BSENGexx|BSENGexx]] = 30 Ry<br />
[[Variables#BSENGBlk|BSENGBlk]] = 4 Ry<br />
% [[Variables#BSEBands|BSEBands]]<br />
6 | 10 | <br />
%<br />
% [[Variables#BEnRange|BEnRange]]<br />
2.00000 | 8.00000 | eV <br />
%<br />
[[Variables#BEnSteps|BEnSteps]]= 200 <br />
% [[Variables#BDmRange|BDmRange]]<br />
0.10000 | 0.10000 | eV <br />
%<br />
% [[Variables#BLongDir|BLongDir]]<br />
1.000000 | 1.000000 | 0.000000 | <br />
%<br />
% [[Variables#KfnQP_E|KfnQP_E]] <br />
1.440000 | 1.000000 | 1.000000 |<br />
%<br />
[[Variables#BSHayTrs|BSHayTrs]]= 0.02000<br />
* Launch the calculation:<br />
> yambo -F 03_bse.in -J 3D_993<br />
* Repeat the procedure for the <code>12x12x4</code> (it will take few minutes) with the difference you will use a different prefix: <code>-J 3D_12124</code>.<br />
<br />
The convergence on the k-point is certainly the most tedious and expensive part. Note that for the two larger meshes the calculations of both the screening and kernel take about 10 to 30 minutes each. <br />
If short of time/resources postpone these calculations. If you have the time and computational resources repeat the above procedure for <code>15x15x5</code> and <code>18x18x6</code>.<br />
<br />
Note that for those meshes the BS kernel database is becoming very/too large and you need to fragment it. To do that '''after''' you generated and modified the input invoke yambo again as:<br />
> yambo -F 03_bse.in -J 3D_15155 -o b -k sex -y h '''-V io'''<br />
and modify the variable <br />
[[Variables#DBsFRAGpm|DBsFRAGpm]]= "+BS"<br />
Then launch the calculation <br />
> yambo -F 03_bse.in -J 3D_15155<br />
<br />
If you correctly followed the above procedure you should have a file with the optical absorption spectrum for each mesh, e.g. <code>o-3D_993.eps_q1_haydock_bse</code>.<br />
To see the effect of k-points plot those files with <code>gnuplot</code> (remember to include the 6x6x2 calculation which should still be inside <code>hBN/YAMBO</code>, if the parameters don't match you simply rerun it here by creating a <code>6x6x2</code> directory and copying the SAVE there):<br />
> gnuplot<br />
plot '18x18x6/o-3D_18186.eps_q1_haydock_bse' w l t '18x18x6, '15x15x5/o-3D_15155.eps_q1_haydock_bse' w l t '15x15x5','12x12x4/o-3D_12124.eps_q1_haydock_bse' w l t '12x12x4, <br />
'9x9x3/o-3D_993.eps_q1_haydock_bse' w l t '9x9x3', '6x6x2/o-3D_662.eps_q1_haydock_bse' w l t '6x6x2'<br />
<br />
[[File:03 bse conv k.png|500px|center|convergence with k points]]<br />
<br />
From this plot you can notice that:<br />
* results with the 6x6x2 mesh are clearly not converged: the first peak is too red shifted, the peak at 6 eV too sharp and intense and there is an 'extra' peak at 7 eV.<br />
* both the position and shape of the first peak are practically converged with the 9x9x3 mesh.<br />
* conversely the second peak is still not fully converged with the 18x18x6.<br />
The different behavior in the convergence of the two features depends on the localization of the exciton. The sharp first peak suggests a localized exciton. The shape of the second peak a much more delocalized exciton. A finer '''k''' mesh, corresponds in direct space, to considering a larger amount of unit cells. Then when the excitation is delocalized over a large number of unit cells a very fine '''k''' mesh is needed. <br />
Typically a too coarse '''k''' mesh induces an artificial localization of the excitons which then correspond to artefacts in the spectrum (similar to what is observed for the 6x6x9). A nice, instructive discussion on wrong deductions from unconverged '''k''' mesh calculations can be found in the Appendix of Molina-Sanchez et al. (2013).<ref>Alejandro Molina-Sánchez, Davide Sangalli, Kerstin Hummer, Andrea Marini, and Ludger Wirtz Phys. Rev. B 88, 045412 (2013)</ref><br />
<br />
==Summary==<br />
<br />
To sum-up the results from this tutorial you have found that for the system under study:<br />
* <code>BSENGBlk= '''3 Ry'''</code><br />
* <code>BSENGexx= '''10 Ry'''</code><br />
* <code>BSEBands '''from 6 to 10'''</code><br />
* To converge the position and shape of the first exciton peak a 12x12x4 mesh is sufficient. For the second exciton peak a mesh larger than 18x18x6 would be needed (indeed Wirtz and co-workers found a k-mesh 24x24x10 was needed.<ref>Ludger Wirtz, Andrea Marini, Myrta Gruning, Angel Rubio in arXiv:cond-mat/0508421 [cond-mat.mtrl-sci]</ref>)<br />
<br />
==Links==<br />
* Go to [[Calculating optical spectra including excitonic effects: a step-by-step guide]] module<br />
* Back to [[Modena 2025]]<br />
* Back to [[Rome 2023#Tutorials]]<br />
* Back to [[BSE hBN Yambo Virtual 2021 version|BSE tutorial sections]]<br />
* Back to [[ICTP 2022]]<br />
* Back to [[CECAM VIRTUAL 2021]]<br />
* [[Modules|Back to technical modules menu]]<br />
* [[Tutorials|Back to tutorials menu]]<br />
<br />
==References==</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=BSE_solvers_overview&diff=8796BSE solvers overview2025-05-21T14:12:18Z<p>Nicolaspallanzani: /* Navigate */</p>
<hr />
<div>This tutorial explores the options available in Yambo for the numerical solution of the Bethe-Salpeter equation. Before running this tutorial, you should have carried out the tutorial '''[[Calculating optical spectra including excitonic effects: a step-by-step guide]]'''. We will use the same example system (bulk hBN). The various options correspond to different numerical methods for solving (large) eigenvalue problems. The numerical methods are not covered in this tutorial and the interested user is directed to the references.<br />
<br />
After completion of this tutorial, you are expected to recognize which solver to use depending on the system, computational load and desired output. Also, for each of the solver, you should be able to choose the values for the key input parameters. <br />
<br />
Three main solvers are available in Yambo:<br />
__TOC__<br />
===Full diagonalization solver===<br />
Diagonalization of the full Hamiltonian using the standard LAPACK library. <br />
<br />
This solver outputs the macroscopic dielectric function over a range of energies chosen by the user. It also calculates all exciton energies and composition in terms of electron-hole pairs. Upon user's choice, the latter is stored on disk for use in postprocessing for exciton analysis and plotting as seen in the tutorial '''[[How to analyse excitons - CECAM 2021 school|How to analyse excitons]]'''. <br />
<br />
Unfortunately, the computational cost of full diagonalization is cubic in the number of electron-hole pairs so this solver can be used for small system only (few light atoms per unit cell). <br />
<br />
You should have already carried out the '''[[Bethe-Salpeter solver: diagonalization]]'''. If you wish, you can run again this part and then '''return to this tutorial'''<br />
<br />
===Lanczos-Haydock solver===<br />
Subspace iterative [https://en.wikipedia.org/wiki/Lanczos_algorithm | Lanczos algorithm] which by-pass diagonalization with the Haydock approach<ref>R. Haydock, in<br />
''Solid State Phys.'', '''35''' 215 (1980) edited by H. Ehrenfest, F. Seitz, and D. Turnbull, Academic Press</ref>.<br />
<br />
This solver outputs the macroscopic dielectric function over a range of energies chosen by the user. It can be applied to medium-large systems as it is substantially cheaper than the full diagonalization (quadratic with the number of electron-hole pairs). However, this approach ''does not provide'' the individual exciton energies and composition in terms of electron-hole pairs.<br />
<br />
Follow the link to '''[[Bethe-Salpeter solver: Lanczos-Haydock]]''' then '''return to this tutorial'''<br />
<br />
===SLEPc solver ===<br />
Subspace iterative algorithm using the [https://slepc.upv.es SLEPc library]<ref>V. Hernandez, J.E. Roman and V. Vidal in '' ACM Transactions on Mathematical Software'', '''31''' 315 (2005)</ref> (SLEPC solver).<br />
<br />
This solver outputs the individual exciton energies and composition about an energy value chosen by the user. It can be applied to medium-large systems but does not provide the overall spectrum. This solver is typically used after obtaining the spectra from the Lanczos-Haydock solver to either analyze a specific peak or getting the energy and composition of a few low-lying excitons. It can be used for large-medium systems. The computational cost grows with the number of excitons one asks to compute. <br />
<br />
'''Optional:'''<br />
Advanced users can recompile Yambo with the ''--enable-slepc-linalg'' option if they hadn't done so. <br />
If/Once you have a Yambo version compiled with the SLEPc, or you have the Virtual Machine or the Docker (with the yambo-gcc_openmp_petsc [[CECAM_VIRTUAL_2021 | container]]), follow the link to '''[[Bethe-Salpeter solver: SLEPC]]''' then '''return to this tutorial'''<br />
<br />
==Summary==<br />
To summarise, the output (dielectric function, exciton energies and composition) and cost of the three solvers are summarized in this table.<br />
<br />
[[File:Solver.png|Yambo tutorial image]]<br />
<br />
<br />
==Navigate==<br />
* Back to [[Modena 2025]]<br />
* Back to [[Rome 2023#Tutorials]]<br />
* Back to [[BSE hBN Yambo Virtual 2021 version|BSE tutorial sections]]<br />
* Back to [[ICTP 2022]]<br />
* Back to [[CECAM VIRTUAL 2021]]<br />
* [[Modules|Back to technical modules menu]]<br />
* [[Tutorials|Back to tutorials menu]]<br />
<br />
=References =<br />
<references /></div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=How_to_analyse_excitons_-_ICTP_2022_school&diff=8795How to analyse excitons - ICTP 2022 school2025-05-21T14:11:02Z<p>Nicolaspallanzani: /* Navigate */</p>
<hr />
<div>In this tutorial you will learn how to:<br />
* analyze an optical spectrum obtained from BSE in terms of excitonic energies and composition<br />
* look at the spatial distribution of the exciton<br />
<br />
This is demonstrated for 3D hBN, for which you should have obtained the needed data from previous calculations. <br />
<br />
'''Warning''': for this demonstration, we did not use converged parameters (in particular they are not converged for the k-grid). Note that one needs to converge carefully all parameters to obtain scientific relevant results. This will be the topic of [[How to choose the input parameters | one of the next tutorials]]. <br />
<br />
<br />
== Prerequisites ==<br />
'''Previous modules'''<br />
* You must have completed the [[Calculating optical spectra including excitonic effects: a step-by-step guide]] tutorial.<br />
'''You will need''':<br />
* The <code>SAVE</code> databases for 3D hBN <br />
* The <code>3D_BSE</code> directory containing the <code>ndb.BS_diago*</code> databases for 3D hBN<br />
* <code>ypp </code> executable<br />
* <code>xcrysden</code> or <code>VESTA</code> executables<br />
* <code>gnuplot</code> executable<br />
'''<br />
<br />
All the databases required for this tutorial should be in the <code>YAMBO_TUTORIALS/hBN/</code> directory.<br />
<br />
Recall that in order to plot excitonic wave functions, you need to have done a BSE calculation with either the <code>diago</code> or <code>slepc</code> solvers and explicitly set the flag <code>WRbsWF</code> to print the wave function databases to disk.<br />
<br />
<!--<br />
== YAMBO calculations ==<br />
Enter the <code>YAMBO_TUTORIALS/hBN/</code> directory. In there you have the <code>SAVE</code> directory<br />
<br />
$ ls ./SAVE<br />
ndb.gops ndb.kindx ns.db1 ns.kb_pp_pwscf_fragment_1 ....<br />
<br />
and the <code>3D_BSE</code> directory<br />
<br />
$ ls ./3D_BSE<br />
ndb.BS_Q1_CPU_0 ndb.BS_diago_Q1 ndb.dip_iR_and_P_fragment_1 ndb.em1s_fragment_1 ...<br />
!--><br />
<br />
==List the excitonic energies==<br />
<br />
First, we will obtain the list of all the exciton energies (that is the eigenvalues of the two-particle Hamiltonian) sorted both by energy and strength. The exciton strengths or intensities are defined from the expression of the optical absorption spectrum as<br />
<br />
[[File:strengh.png|none|x150px|]]<br />
<br />
That is, they are given by the linear combination of the square of the dipole transition matrix elements between electron-hole pairs, where A<sup>&lambda;</sup><sub>''eh''</sub> is the exciton composition in terms of electron-hole pairs. <br />
<br />
To read this information from the Yambo databases produced in [[Bethe-Salpeter solver: diagonalization| this previous step]], we use the Yambo pre- and post-processing utility <code>ypp</code>.<br />
<br />
Type:<br />
<br />
$ ypp -J 3D_BSE -e s 1<br />
<br />
<br />
This instructs the code to list the excitons (<code>-e s</code>) in the database ''3D_BSE'' (<code>-J 3D_BSE</code>) for the q-index = 1 (optical limit q=0). <br />
<br />
The results are output in the files ''o-3D_BSE.exc_qpt1_E_sorted'' and ''o-3D_BSE.exc_qpt1_I_sorted''. <br />
They report the energies of the excitons and their strengths. The strengths are normalised to the largest strength. Thus in the list, the brightest exciton has strength 1. <br />
In ''o-3D_BSE.exc_qpt1_E_sorted'' the exciton energies are sorted by energy (lower to higher), in ''o-3D_BSE.exc_qpt1_I_sorted'' by the oscillator strength (larger to smaller).<br />
<br />
Inspect ''o-3D_BSE.exc_qpt1_E_sorted'': <br />
<br />
The exciton with the lowest energy (4.98 eV) is doubly degenerate. The strength is ~0, thus this exciton is dark, does not contribute to the absorption spectrum. <br />
<br />
The second-lowest exciton is also doubly degenerate and it is the brightest (one of the components has strength 1, the other ~0.03). The latter exciton is the one responsible for the largest peak in the optical absorption plots of the [[Bethe-Salpeter solver: diagonalization|previous tutorials]].<br />
<br />
To better visualize these results, we plot the exciton strength (normalized to 1, arbitrary units) versus the energy (in eV):<br />
$ gnuplot<br />
gnuplot> set style line 2 lc rgb 'black' pt 7 # circle<br />
gnuplot> plot 'o-3D_BSE.exc_qpt1_E_sorted' with points ls 2 title 'Strengths'<br />
<br />
[[File:Exc weights3DhBN2.png|none|600px]]<br />
<br />
== Calculate the exciton oscillator strength and amplitude ==<br />
<br />
Once inspected the list of excitons sorted by energies and strengths, we will look at the composition of some of these excitons in terms of single-particle states (electron-hole pairs). <br />
<br />
Type: <br />
$ ypp -F ypp_AMPL.in -J 3D_BSE -e a 1 <br />
<br />
This instructs the code to create the the input file ''ypp_AMPL.in'' (<code>-F ypp_AMPL.in</code>) to analyze the composition of the excitons (<code>-e a</code>) in the database ''3D_BSE'' (<code>-J 3D_BSE</code>) for the q-index = 1 (optical limit q=0). <br />
<br />
You can now edit the input file ''ypp_AMPL.in''. From the list of excitons, we should have got an idea of which excitons we wish to analyze. The ordering from the list of exciton sorted by energies in ''o-3D_BSE.exc_qpt1_E_sorted'' is used to identify the excitons to analyse.<br />
<br />
For example, to analyse the 4 lowest-energy excitons (i.e., the first 2 doubly-degenerate excitons of which the first is dark and the second is bright) change this line as:<br />
States= "1 - 4" # Index of the BS state(s)<br />
<br />
Close the input file and run <code>ypp</code> again by typing<br />
<br />
$ ypp -F ypp_AMPL.in -J 3D_BSE<br />
<br />
This carries out the analysis for the specified excitons. The results are output in ''o-3D_BSE.exc_qpt1_amplitude_at_*'' and ''o-3D_BSE.exc_qpt1_weights_at_*'', where ''*'' identifies the exciton according to the order in ''o-3D_BSE.exc_qpt1_E_sorted''.<br />
<br />
$ ls o*exc*at*<br />
o-3D_BSE.exc_qpt1_amplitude_at_1 o-3D_BSE.exc_qpt1_weights_at_1 ...<br />
<br />
For an exciton <math>|\lambda></math> , ''o-3D_BSE.exc_qpt1_weights_at_*'' reports the weights defined as <br />
[[File:Weights.png|none|x60px|]]<br />
and ''o-3D_BSE.exc_qpt1_amplitude_* '' reports the amplitudes defined as <br />
[[File:Ampl.png|none|x70px|]]<br />
<br />
<br />
Inspect, for example, the file ''o-3D_BSE.exc_weights_at_3'' (which we learned from ''o-3D_BSE.exc_qpt1_E_sorted'' has the largest strength) <br />
<br />
# Band_V Band_C Kv-q ibz Symm_kv Kc ibz Symm_kc Weight Energy<br />
# <br />
7.00000000 10.0000000 14.0000000 2.00000000 14.0000000 2.00000000 0.395135850 4.35248947 <br />
7.00000000 10.0000000 14.0000000 1.00000000 14.0000000 1.00000000 0.394993663 4.35248947 <br />
8.00000000 9.00000000 14.0000000 2.00000000 14.0000000 2.00000000 0.391943455 4.35241365 <br />
8.00000000 9.00000000 14.0000000 1.00000000 14.0000000 1.00000000 0.391800284 4.35241365 <br />
7.00000000 10.0000000 13.0000000 2.00000000 13.0000000 2.00000000 0.745555162E-1 4.81094742 <br />
7.00000000 10.0000000 13.0000000 1.00000000 13.0000000 1.00000000 0.745274872E-1 4.81094742 <br />
8.00000000 9.00000000 13.0000000 2.00000000 13.0000000 2.00000000 0.739243180E-1 4.81087065 <br />
8.00000000 9.00000000 13.0000000 1.00000000 13.0000000 1.00000000 0.738964081E-1 4.81087065 <br />
<br />
The third exciton is mostly composed of single-particle transitions from VBM to CBM at point H (last k-point of the grid, number 14) of the 3D hexagonal Brillouin zone, with contributions also coming from point K (number 13). All the contributions weighing less than 5% are not shown by default. <br />
<br />
Recall from the previous analysis that of the first 4 exciton states, exciton states 3 and 4 (degenerate) are the optically active ones. We plot then the amplitude of the lowest energy bright exciton:<br />
$ paste o-3D_BSE.exc_qpt1_amplitude_at_3 o-3D_BSE.exc_qpt1_amplitude_at_4 > o-3D_BSE.exc_qpt1_amplitude_at_3_4<br />
$ gnuplot<br />
gnuplot> set xlabel 'Energy (eV)' <br />
gnuplot> set ylabel 'Amplitude' <br />
gnuplot> p 'o-3D_BSE.exc_qpt1_amplitude_at_3_4' u 1:($2+$4)/2 w l t 'Bright exciton'<br />
<br />
[[File:ExcAmp3DhBN.png|none|600px]]<br />
<br />
Note that while this plot is related to the peaks in the optical absorption spectrum, it does not take into account the dipole matrix elements and the peaks appear at the energies of the single-particle transitions rather than the exciton energies.<br />
<br />
== Plot the exciton spatial distribution ==<br />
<br />
A further analysis we carry out is on the spatial distribution of the exciton, specifically of the probability of finding the electron at a certain position r when the hole is fixed in a position r'.<br />
<br />
Create the input file ``ypp_WF.in`` using the command below and change the various parameters as shown below: <br />
<br />
$ ypp -F ypp_WF.in -J 3D_BSE -e w<br />
<br />
excitons # [R] Excitons<br />
wavefunction # [R] Wavefunction<br />
Format= "x" # Output format [(c)ube/(g)nuplot/(x)crysden]<br />
Direction= "123" # [rlu] [1/2/3] for 1d or [12/13/23] for 2d [123] for 3D<br />
FFTGvecs= 30 Ry # [FFT] Plane-waves<br />
States= "3 - 3" # Index of the BS state(s)<br />
Degen_Step= 0.0100 eV # Maximum energy separation of two degenerate states<br />
% Cells<br />
5 | 5 | 1 | # Number of cell repetitions in each direction (odd or 1)<br />
%<br />
% Hole<br />
2.35800028 | 1.36139178 | 7.08835602 # [cc] Hole position in unit cell (positive)<br />
%<br />
<br />
<code>Cells</code>, is the size of the cell where the exciton will be visualised.<br />
If the k-grid used for the BSE calculations is XxYxZ, then the exciton has an induced fictitious periodicity for every XxYxZ cells of the simulation.<br />
For hBN, this is not a problem because the first bright exciton is strongly localized, but in other systems, where excitons are more delocalized, one must use very large k-grids for the BSE calculation.<br />
<br />
<code>Degen_Step</code>, tells the maximum energy separation of two degenerate states. Since this value is small enough, the code will automatically recognize excitons 3 and 4 are degenerate and merge them: you can check this in the log file.<br />
<br />
Plots can be in 1, 2 or 3D (<code>Direction</code>) and the output format is chosen with <code>Format</code>. <br />
<br />
A non-trivial input parameter is the hole position. The best position for the hole is where the valence electrons contributing to the exciton are localised. In the case of hBN, they are on the nitrogen atoms. We can obtain the Cartesian coordinates of these atoms from our previously generated ''o-3D_BSE.exc_qpt1_E_sorted'' file:<br />
# Atom 1 with Z 5 [cc]: 2.35800028 1.36139178 0.00000000 <br />
# Atom 2 with Z 5 [cc]: -2.35800028 -1.36139178 6.08835602 <br />
# Atom 1 with Z 7 [cc]: -2.35800028 -1.36139178 0.00000000 <br />
# Atom 2 with Z 7 [cc]: 2.35800028 1.36139178 6.08835602 <br />
We take the positive values of the nitrogen (Z=7, last line) and shift the vertical position of the hole from 6.088 to 7.088 so that the hole does not end up in the center of the atom (and therefore, possibly in a node of the wave function). <br />
<br />
Close the input file and run <code>ypp</code> by typing <br />
$ ypp -F ypp_WF.in -J 3D_BSE<br />
<br />
After the calculation is completed, we can visualise the output with xcrysden or with VESTA (if you are running this tutorial on a remote cluster, you should download the *.xsf file using <code>scp</code> or <code>rsync</code>):<br />
<br />
$ xcrysden --xsf o-3D_BSE.exc_qpt1_3d_3.xsf<br />
<br />
$ VESTA o-3D_BSE.exc_qpt1_3d_3.xsf<br />
<br />
[[File:ExcWF3DhBN.jpg|none|600px]]<br />
<br />
We notice that the electron is completely confined on the boron atoms and on the same layer of the hole. For comparison, see for example ref. <ref>Huge Excitonic Effects in Layered Hexagonal Boron Nitride, B. Arnaud et al., [https://arxiv.org/abs/cond-mat/0503390 preprint ArXiv]</ref>.<br />
<br />
== Plot electron/hole average density (only in Yambo 5.x)==<br />
<br />
Another way to analyze the spatial character of excitons is to plot the average electron/hole densities defined as:<br />
<br />
[[File:Electron hole density.png|400px]]<br />
<br />
To generate the input file ypp_WF.in type<br />
<br />
ypp -F ypp_WF.in -e w -avehole<br />
<br />
and choose the exciton you want to plot according to the list of energy-sorted excitons. The electron/hole average densities correspond to generalized valence/conduction orbitals for a given exciton. They are interesting in particular for molecular crystals because they allow distinguishing charge-transfer versus Frenkel excitons, from the relative position of the electron/hole densities.<br />
<br />
If you want to see an example of hole/electron density of excitons please have a look at Ref. <ref>Strongly Bound Excitons in Metal-Organic Framework MOF-5: A Many-Body Perturbation Theory Study, A. R. Kshirsagar et al., [https://doi.org/10.26434/chemrxiv.14034917.v1 preprint ChemRxiv]</ref>.<br />
<br />
== Summary ==<br />
From this tutorial you've learned:<br />
* How sort excitonic states by energy and intensity<br />
* Analyse their composition in reciprocal space and in terms of single-particle transitions<br />
* Visualize the exciton wave function in real space<br />
<br />
=References =<br />
<references /><br />
<br />
==Navigate==<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide]] tutorial<br />
* Back to [[Modena 2025]]<br />
* Back to [[Rome 2023#Tutorials]]<br />
* Back to [[ICTP 2022]]<br />
* [[BSE hBN Yambo Virtual 2021 version|Back to CECAM 2021 tutorial page for the BSE]]<br />
* [[Tutorials|Back to tutorials menu]]<br />
* [[Modules|Back to technical modules menu]]<br />
* Similar tutorial for 2D-hBN and including finite-momentum BSE: [[How to analyse excitons|this page]].</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Calculating_optical_spectra_including_excitonic_effects:_a_step-by-step_guide&diff=8794Calculating optical spectra including excitonic effects: a step-by-step guide2025-05-21T14:09:35Z<p>Nicolaspallanzani: /* Links */</p>
<hr />
<div>This tutorial guides you through the workflow of a calculation of the optical spectrum of a given material by solving the Bethe-Salpeter equation.<br />
Specifically, we will use [[Bulk material: h-BN|bulk h-BN]] as an example.<br />
<br />
[[File:HBN-bulk-3x3-annotated.png|x200px|center|Atomic structure of bulk hBN]]<br />
<br />
Before starting, you need to obtain the tarballs for hBN. See instructions on the [[Tutorials|main tutorials page]].<br />
<br />
The target quantity in a Bethe-Salpeter calculation is the macroscopic dielectric matrix &epsilon;<sub>M</sub>. The following quantities/steps are needed to obtain &epsilon;<sub>M</sub>: <br />
<br />
[[File:Scheme1b.png|500px|center|BSE calculation scheme]]<br />
<br />
The optical absorption spectrum corresponds to Im&epsilon;<sub>M</sub>(&omega;). Following this scheme we go through the flow of a calculation:<br />
__TOC__<br />
<br />
===Step 1: Static screening===<br />
Use the ''SAVE'' folders that are already provided and type:<br />
$ cd YAMBO_TUTORIALS/hBN/YAMBO<br />
<br />
Follow the '''[[Static screening]]''' module and then '''return to this tutorial '''<br />
<br />
===Step 2: Bethe-Salpeter kernel===<br />
Follow the module on '''[[Bethe-Salpeter kernel]]''' and '''return to this tutorial''' <br />
<br />
===Step 3: Diagonalisation of the excitonic Hamiltonian ===<br />
This is the step in which you obtain the spectra. Mathematically this implies solving a large eigenvalue problem. In this tutorial, we diagonalise the whole Bethe-Salpeter matrix, but there are other numerical approaches available in Yambo. The difference between these approaches and when they should be used is the object of [[BSE solvers overview|one of the next tutorials]]. <br />
<br />
Follow the module on '''[[Bethe-Salpeter solver: diagonalization]]''' then '''return to this tutorial'''<br />
<br />
===Step 4: Include previous quasiparticle (GW) results ===<br />
In Step 3, we included the quasiparticle corrections to the Kohn-sham energies as a scissor operator. An alternative is to use the results from a previous run of Yambo.<br />
<br />
Follow the module on '''[[Bethe-Salpeter on top of quasiparticle energies]]''' and '''return to this tutorial'''<br />
<br />
==Links==<br />
* Back to [[Modena 2025]]<br />
* [[Modules|Back to technical modules menu]]<br />
* [[Tutorials|Back to tutorials menu]]<br />
<br />
<!-- <br />
= Calculating the effective two-particle Hamiltonian = <br />
<br />
This first part calculates and stores the two-particle Hamiltonian matrix elements:<br />
[[File:BSE1-Eq1.png|none|x50px]]<br />
where ''vc'''''k''' indicates the pair of quasiparticle states ''v'''''k''' and ''c'''''k'''.<br />
The first term on the RHS is the quasiparticle energy differences (diagonal only). The second term is the kernel which is the sum of the electron-hole exchange part ''V'' (which stems from the Hartree potential) and the electron-hole attraction part ''W'' (which stems from the screened exchange potential). The kernel both shifts (diagonal contributions) and couples (off-diagonal contributions) the quasiparticle energy differences. <br />
<br />
We start the calculation by running the [[Initialization|initialization step]] (i.e. invoke yambo from the command line in the directory containing the relevant SAVE directory).<br />
<br />
== Step1: Calculation of the static dielectric screening.==<br />
<br />
Next, to calculate the correlation part of the kernel ''W'' we need the static dielectric screening. This is a calculation of the linear response of the system analogous to the calculation of the [[RPA/IP]] dielectric function. One important difference is that here we consider the static dielectric function. <br />
[[File:BSE1-Eq2.png|none|x50px]]<br />
<br />
<br />
Start by [[Input file generation|generating the input]] by invoking yambo with the option "-b" from the command line:<br />
<br />
$ yambo -b -F 01_3D_BSE_screening.in<br />
<br />
The input opens in the standard editor. Similarly to the other linear response calculations the relevant input variables to be changed are: <br />
<br />
% [[Variables#BndsRnXs|BndsRnXs]]<br />
1 | 40 | <br />
%<br />
[[Variables#NGsBlkXs|NGsBlkXs]]= 4 Ry<br />
<br />
The first variable gives how many bands are included in the sum to calculate the static response function. The second is a cutoff for the dimension of the static dielectric matrix.<br />
<br />
In the [[How to choose the input parameters|next tutorial]] you will see how to choose these two parameters. Another relevant input parameter to change is<br />
<br />
% [[Variables#LongDrXs|LongDrXs]]<br />
1.000 | 1.000| 1.000<br />
%<br />
<br />
so that the perturbing electric field has component in each direction.<br />
<br />
Run the calculation by invoking yambo:<br />
$ yambo -F 01_3D_BSE_screening.in -J 3D_BSE <br />
<br />
In the log (l_em1s) of the calculation you can see that after calculating the dipole matrix elements, for each q vector yambo calculates the IP response function and by inversion the RPA response function <br />
<br />
<02s> Xo@q[1] |########################################| [100%] --(E) --(X)<br />
<02s> X@q[1] |########################################| [100%] --(E) --(X)<br />
<br />
In the report, r_em1s, the details of the calculations are reported under the 5th section<br />
<br />
[05] Static Dielectric Matrix<br />
=============================<br />
<br />
This calculation does not produce any human readable output, but both the dipole matrix elements and the static screening dielectric function are saved in a database in the 3D_BSE directory:<br />
<br />
3D_BSE/ndb.dip_iR_and_P<br />
3D_BSE/ndb.em1s<br />
<br />
which are needed and read by the following yambo runlevels.<br />
<br />
== Step2: Calculation of matrix elements of the BSE kernel ==<br />
<br />
You have now all ingredients to calculate the kernel <br />
<br />
[[File:BSE1_Eq3.png|none|x100px]]<br />
<br />
<br />
(and thus the two-particle Hamiltonian matrix elements).<br />
<br />
Start by generating the input by invoking yambo with the option "-o b -k bse -V qp" from the command line:<br />
<br />
$ yambo -o b -k bse -V qp -F 02_3D_BSE_kernel.in<br />
<br />
The input opens in the standard editor. The relevant input parameters to be changed are <br />
<br />
[[Variables#BSENGexx|BSENGexx]] = 30 Ry<br />
[[Variables#BSENGBlk|BSENGBlk]] = 4 Ry<br />
% [[Variables#BSEBands|BSEBands]]<br />
6 | 10 | <br />
%<br />
The first two are the cutoff for the summations on the reciprocal lattice vectors which appear in the expressions for ''V'' (BSENGexx) and ''W'' (BSENGBlk) here above. <br />
<br />
The third parameter gives the range of quasiparticle states (their band index) that define the basis of quasiparticle pairs that we need to describe the excitons (in the energy range of interest).<br />
For example since we have 8 occupied bands, here we consider the pairs of bands: ''6-9'', ''6-10'', ''7-9'', ''7-10'', ''8-9'', ''8-10'' (those are 6 pairs of bands = 2 valence times 3 conduction bands). <br />
<br />
For each of those pairs we then consider all '''k''' points in the Brillouin zone available from the DFT calculations. Since we have a ''6 x 6 x 2'' grid, this amounts to 72 '''k''' points in the Brillouin zone. <br />
<br />
Then finally we are using a basis of ''6 x 72 = 432'' ''vc'''''k''' pairs to represent the excitons of the system. <br />
<br />
The values for these 3 parameters are chosen from convergence studies, as discussed in the [[How to choose the input parameters|next tutorial]].<br />
<br />
Another parameter to modify is<br />
% [[Variables#KfnQP_E|KfnQP_E]] <br />
1.440000 | 1.000000 | 1.000000 |<br />
%<br />
This gives the quasiparticle corrections to the Kohn-Sham eigenvalues and is deduced either from experiment or previous [[How to obtain the quasi-particle band structure of a bulk material: h-BN|GW calculations]]. <br />
The corrections consist in a shift (first value) of the conduction bands in eV and renormalization of the conduction and valence bandwidths (second and third value). <br />
Alternatively we can directly input corrections calculated from a previous GW calculation as we will learn later in this tutorial.<br />
<br />
Run the calculation by invoking yambo in the command line:<br />
$ yambo -F 02_3D_BSE_kernel.in -J 3D_BSE <br />
In the log (either in standard output or in l_optics_bse_bsk), after various setup/loading, the kernel is calculated: <br />
<br />
<01s> [05.04.03] Kernel loop<br />
<02s> Kernel |########################################| [100%] --(E) --(X)<br />
<br />
In the report r_optics_bse_bsk the information relative to this runlevel are reported under the section:<br />
<br />
<br />
[05] Response Functions in Transition space<br />
===========================================<br />
<br />
<br />
Take some time to inspect the log and the report. For example try to find where the input parameters are reported, the dimension of the 2-particle hamiltonian and if these match your expectations.<br />
<br />
This run does not produce any human readable output. The kernel is stored in a database in the 3D_BSE directory<br />
<br />
3D_BSE/ndb.BS_Q1<br />
<br />
= Obtaining the optical spectrum from the two-particle Hamiltonian =<br />
The macroscopic dielectric function (from which the absorption and EEL spectra can be computed) is obtained from the eigenvalues ''E''<sub>&lambda;</sub> (excitonic energies) and eigenvectors A<sup>&lambda;</sup><sub>''cv'''''k'''</sub> (exciton composition in terms of electron-hole pairs) of the two-particle Hamiltonian:<br />
<br />
[[File:BSE1-Eq4.png|none|x50px]]<br />
<br />
To get the two-particle Hamiltonian eigensolutions you can either <br />
<br />
(1) diagonalize the full Hamiltonian (diagonalization solver) <br />
<br />
(2) use the subspace iterative [https://en.wikipedia.org/wiki/Lanczos_algorithm | Lanczos algorithm] and by-pass diagonalization with the Haydock approach<ref>R. Haydock, in<br />
''Solid State Phys.'', '''35''' 215 (1980)<br />
edited by H. Ehrenfest, F. Seitz, and D. Turnbull, Academic Press</ref> (Lanczos-Haydock solver)<br />
<br />
Both approaches are detailed here below.<br />
<br />
== Diagonalization solver ==<br />
<br />
Invoke yambo with the "-y d" option in the command line:<br />
<br />
$ yambo -y d -F 03_3D_BSE_diago_solver.in<br />
<br />
The input is open in the editor. The input variable to be changed are <br />
% [[Variables#BEnRange|BEnRange]]<br />
2.00000 | 8.00000 | eV <br />
%<br />
[[Variables#BEnSteps|BEnSteps]]= 200 <br />
<br />
which define 200 evenly spaced points between 2 and 8 eV at which the spectrum is calculated (&omega; in the equation for the macroscopic dielectric function),<br />
<br />
% [[Variables#BDmRange|BDmRange]]<br />
0.10000 | 0.10000 | eV <br />
%<br />
<br />
which defines the spectral broadening (Lorentzian model), <br />
<br />
% [[Variables#BLongDir|BLongDir]]<br />
1.000000 | 1.000000 | 0.000000 | <br />
%<br />
<br />
which defines the direction of the perturbing electric field (in this case the in-plane direction).<br />
<br />
Run yambo: <br />
$ yambo -F 03_3D_BSE_diago_solver.in -J 3D_BSE <br />
In the log (either in standard output or in l-3d_BSE_optics_bse_bsk_bss), after various setup/loading, the BSE is diagonalized using the linked linear algebra libraries: <br />
<01s> [06] BSE solver(s)<br />
<01s> [LA] SERIAL linear algebra<br />
<01s> [06.01] Diagonalization solver<br />
<01s> BSK diagonalize |########################################| [100%] --(E) --(X)<br />
<01s> EPS residuals |########################################| [100%] --(E) --(X)<br />
<01s> BSK epsilon |########################################| [100%] --(E) --(X)<br />
The report r-3d_BSE_optics_bse_bsk_bss contains information relative to this runlevel in section 6:<br />
<br />
[06] BSE solver(s)<br />
==================<br />
<br />
Take some time to inspect the log and the report to check the consistency with the input variables. This run produces a new database in the 3D_BSE directory<br />
3D_BSE/ndb.BS_diago_Q01<br />
So if you need the spectrum on a different energy range, direction, with a different broadening or on more points the diagonalization is not repeated, just the spectrum is recalculated.<br />
<br />
This run produces as well human readable files (o-*). Specifically o-3D_BSE.eps_q1_diago_bse contains the real and imaginary part of the macroscopic dielectric function <br />
<br />
$ less o-3D_BSE.eps_q1_diago_bse <br />
...<br />
#<br />
# E/ev[1] EPS-Im[2] EPS-Re[3] EPSo-Im[4] EPSo-Re[5]<br />
#<br />
2.00000 0.16162 5.83681 0.04959 4.14127<br />
2.03015 0.16787 5.88612 0.05090 4.15638<br />
...<br />
<br />
which is in the format <br />
Energy in eV | Imaginary part BSE | Real part BSE |Imaginary part IPA | Real part IPA | <br />
<br />
where real and imaginary parts refer to the macroscopic dielectric function. The imaginary part corresponds to the optical absorption. The latter (column 2) can be plotted versus the photon energy (column 1) and compared with the independent particle approximation (IPA, column 4), e.g.: <br />
<br />
$ gnuplot<br />
...<br />
plot 'o-3D_BSE.eps_q1_diago_bse' u 1:2 w l t 'BSE', 'o-3D_BSE.eps_q1_diago_bse' u 1:4 w l t 'IPA'<br />
<br />
[[file:03_bse_diago.png |none|600px]]<br />
The addition of the kernel has the effect to red-shift the spectrum onset and to redistribute the oscillator strengths. Note that the convergence with respect to k-points smooths out the low energy peaks in the IPA (which are an artifact of poor convergence with k-points producing an artificial confinement) to give the shoulder corresponding to the van Hove singularity in the band structure. On the other hand the low energy peak in the BSE is genuine and it is the signature of a bound exciton.<br />
<br />
== Lanczos-Haydock solver ==<br />
<br />
You can avoid the full matrix diagonalization (which rapidly become expensive as it scales as N<sup>3</sup>) by using the Lanczos-Haydock solver mentioned above. While for small matrices these two methods have similar computational cost, for matrices of the size 10000 by 10000 and larger, the Haydock solver is remarkably faster. The drawback is that excitonic functions cannot be calculated.<br />
Within the Lanczos-Haydock approach the macroscopic dielectric function is rewritten as continued fraction<ref>L. X. Benedict and E. L. Shirley, Phys. Rev. B '''59''', 5441 (1999)</ref><br />
<br />
[[file:BSE1-Eq5.png|none|x100px]]<br />
<br />
where ''a'' 's and ''b'' 's result from the [https://en.wikipedia.org/wiki/Lanczos_algorithm#Lanczos_method| Lanczos iterative algorithm]. <br />
<br />
To use the Lanczos-Haydock solver invoke yambo with "-y h" option in the command line:<br />
<br />
$ yambo -y h -F 03_3D_BSE_haydock_solver.in<br />
Beside the same input parameters defined for the diagonalization solver, the parameter<br />
[[Variables#BSHayTrs|BSHayTrs]]= -0.02000 <br />
defines the threshold accuracy for the Lanczos-Haydock iterative process: the calculation stops when the difference between two consecutive calculated spectra is smaller than the absolute value of the threshold. <br />
The minus sign indicates that the average difference over the specified energy range is considered (i.e. that means that cancellations of error may occur) as opposed to the maximum absolute difference over the specified energy range (plus sign). For the moment we leave this variable unchanged. This parameter ultimately determines the terms are included in the continued fraction here above. Later we explore how this variable influences the final result. <br />
<br />
Invoke yambo to run the calculation:<br />
$ yambo -F 03_3D_BSE_haydock_solver.in -J "3D_BSE-low,3D_BSE" <br />
This outputs the following log:<br />
...<br />
<01s> [06] BSE solver(s)<br />
<01s> [06.01] Haydock solver<br />
<01s> [Haydock] Iteration 1<br />
<03s> [Haydock] Iteration 21 Accuracy : 0.01647| -0.02000<br />
...<br />
The Lanczos-Haydock iterative procedure converged to the desired accuracy in 21 iterations.<br />
<br />
This runs only produces human readable files. That means that if you changes the input parameters (such as the broadening or the energy range) the Lanczos-Haydock procedure has to be repeated. <br />
Among the human readable files, o-3D_BSE-low.eps_q1_haydock_bse contains the real and imaginary part of the macroscopic dielectric function:<br />
$ less o-3D_BSE-low.eps_q1_haydock_bse<br />
...<br />
#<br />
# E/ev[1] EPS-Im[2] EPS-Re[3] EPSo-Im[4] EPSo-Re[5] EPS`-Im[6] EPS`-Re[7]<br />
#<br />
2.00000 0.16089 5.81293 0.04945 4.12727 0.16089 5.81293<br />
2.03015 0.16711 5.86203 0.05076 4.14234 0.16711 5.86203<br />
...<br />
This file has a slightly different data structure with respect to the diagonalization solver:<br />
Energy in eV | Imaginary part BSE | Real part BSE |Imaginary part IPA | Real part IPA |Imaginary part BSE (it-1) | Real part BSE (it-1)|<br />
<br />
We can plot the second and sixth columns and compare with the result from diagonalization:<br />
$gnuplot<br />
...<br />
plot 'o-3D_BSE.eps_q1_diago_bse' u 1:2 w l t 'Diagonalization', 'o-3D_BSE-low.eps_q1_haydock_bse' u 1:2 w l t 'Haydock (27 its)', 'o-3D_BSE-low.eps_q1_haydock_bse' u 1:6 w l t 'Haydock (26 its)'<br />
[[file:03_bse_haydock.png|none|600px]]<br />
Except for the peak at higher energy, the results on this scale are identical to those obtained via the diagonalization solver. By comparing the results for the Lanczos-Haydock solver at 27 and 26 iterations, it is clear that the difference with the diagonalization results can be eliminated by lowering the threshold for the iterative process.<br />
<br />
Repeat now the calculation by changing the input variable:<br />
[[Variables#BSHayTrs|BSHayTrs]]= 0.02000 <br />
which enforces a stricter condition on the convergence of the iterative process (see above)<br />
<br />
Running yambo: <br />
$ yambo -F 03_3D_BSE_haydock_solver.in -J "3D_BSE-high,3D_BSE" <br />
outputs the following log <br />
...<br />
<01s> [06] BSE solver(s)<br />
<01s> [06.01] Haydock solver<br />
<01s> [Haydock] Iteration 1<br />
<06s> [Haydock] Iteration 45 Accuracy : 0.0098| 0.02000<br />
...<br />
Now 45 iterations, rather than 21, were needed to reach the desired accuracy.<br />
By plotting these results:<br />
$ gnuplot<br />
plot 'o-3D_BSE.eps_q1_diago_bse' u 1:2 w l ls 1 t 'Diagonalization', 'o-3D_BSE-high.eps_q1_haydock_bse' u 1:2 w l ls 2 t 'Haydock (high)', 'o-3D_BSE-low.eps_q1_haydock_bse' u 1:2 w l ls 3 t 'Haydock (low)'<br />
[[file:03_bse_haydock_high.png|none|600px]]<br />
Which shows that the Lanczos-Haydock solver with the stricter convergence criterion and the diagonalization solver are identical on this scale.<br />
<br />
=Some more advanced options =<br />
<br />
==Reading the QP corrections from a previous ''GW'' calculation==<br />
In the above calculation we have used a simple scissor operator to correct the Kohn-Sam DFT energies. In this part we see how we can instead take the corrections from a previous Yambo Gw calculation.<br />
We create and edit the input. This time instead of proceeding in three steps as before, we create one input performing all three steps:<br />
$yambo -o b -k sex -y d -V qp -F Ins/05_3D_QP_BSE.in<br />
We set all parameters as in the previous calculation, except for the part regarding the QP correction:<br />
[[Variables#KfnQPdb|KfnQPdb]]= "E < 3D_QP_BSE/ndb.QP" # [EXTQP BSK BSS] Database<br />
[[Variables#KfnQP_N|KfnQP_N]]= 1 # [EXTQP BSK BSS] Interpolation neighbours<br />
% [[Variables#KfnQP_E|KfnQP_E]]<br />
0.000000 | 1.000000 | 1.000000 | # [EXTQP BSK BSS] E parameters (c/v) eV|adim|adim<br />
%<br />
Instead of setting the values for the scissor, we give the path to a database (3D_QP_BSE/ndb.QP) which contains the QP corrections. This has been created by running a GW calculation as in the [[How to obtain the quasi-particle band structure of a bulk material: h-BN |GW tutorial]].<br />
Run Yambo:<br />
$ yambo -F Ins/05_3D_QP_BSE.in -J "3D_QP_BSE,3D_BSE"<br />
This produces the following log in the standard output. Note Section 4 (regarding external QP corrections to the kernel):<br />
<01s> [04.01] External QP corrections (K)<br />
<01s> [QP@K] E<3D_QP_BSE/ndb.QP[ PPA XG:39 Xb:1 40 Scb:1 40]<br />
<01s> [QP] Kpts covered exactly [o/o]: 100.0000<br />
This tells you that the file was found, read correctly and that the '''k''' points found in the file matched the ones you are using for the current calculation (otherwise interpolation would be needed).<br />
It is crucial to check that the file has been read, since if not Yambo gives a warning but continues the calculation (with no QP corrections at all!).<br />
As in the previous calculation the final results of the calculation are the files with the spectral functions. Let's compare the results for the optical absorption spectrum with those obtained previously with a simple scissor:<br />
$ gnuplot<br />
...<br />
plot 'o-3D_QP_BSE.eps_q1_diago_bse' u 1:2 w l t 'Explicit QP', 'o-3D_BSE.eps_q1_diago_bse' u 1:2 w l t 'Scissor' <br />
[[File:03 bse diago qp.png|none|600px]]<br />
It is clear that this makes a difference in the peak distribution and intensity. Note that beside a simple shift you can renormalise as well the bandwidth of the valence and conduction bands in KfnQP_E (respectively the third and second value). You can try as an exercise to set up a new calculation using e.g. 1.440000 | 1.200000 | 0.900000 | for KfnQP_E.<br />
<br />
<br />
=References =<br />
<references /><br />
--></div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8761Modena 20252025-05-19T13:01:17Z<p>Nicolaspallanzani: /* Tutorials */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
<blockquote><br />
Be aware that when running the <code>ssh-copy-id</code> command, after typing "yes" at the prompt, you might see an error message like the one shown below. Don’t worry—just follow the instructions provided in this CINECA [https://wiki.u-gov.it/confluence/display/SCAIUS/FAQ#FAQ-Ikeepreceivingtheerrormessage%22WARNING:REMOTEHOSTIDENTIFICATIONHASCHANGED!%22evenifImodifyknown_hostfile guide to resolve the issue]. Once done, run the <code>ssh-copy-id</code> command again.<br />
</blockquote><br />
/usr/bin/ssh-copy-id: <br />
ERROR: @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@<br />
ERROR: @ WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! @<br />
ERROR: @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@<br />
ERROR: IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!<br />
[...]<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
ssh leonardo<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
#SBATCH --reservation=s_tra_yambo # Reservation specific to this school<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
<br />
Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resources]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh username R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hours:<br />
srun -A tra25_yambo -p dcgp_usr_prod --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command:<br />
exit<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first activate the python environment:<br />
module load profile/candidate<br />
source /leonardo_work/tra25_yambo/env_yambopy/bin/activate<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
Since the compute nodes are not connected to the external network, the tarballs must be downloaded before starting the interactive session.<br />
Alternatively, once the interactive session has started, it is possible to access the tarballs by copying them from the following directories:<br />
<br />
/leonardo_work/tra25_yambo/YAMBO_TUTORIALS<br />
/leonardo_work/tra25_yambo/YAMBOPY_TUTORIALS<br />
<br />
After that you can start the interactive session<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
<br />
set the environment variable for openMP <br />
<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
and load yambo or yambopy as explained above in the general instructions.<br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>srun</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
$ cd $SCRATCH<br />
$ mkdir -p YAMBOPY_TUTORIALS<br />
$ cd YAMBOPY_TUTORIALS<br />
$ rsync -avzP /leonardo_work/tra25_yambo/YAMBOPY_TUTORIALS/yambopy_tutorial_Modena_2025.tar.gz .<br />
$ tar --strip-components=1 -xvzf yambopy_tutorial_Modena_2025.tar.gz<br />
<br />
Then, follow part 1 of the tutorial, which is related to DFT band structures, YAMBO initialization and linear response.<br />
* [[Modena 2025 : Yambopy part 1]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
$ cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
$ cd $SCRATCH<br />
$ cd YAMBO_TUTORIALS<br />
$ cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
As for yambopy, the tutorial related to GW calculations is contained in the first section of Part 2<br />
<br />
* [[Modena 2025 : Yambopy part 2#GW calculations| Modena 2025 : Yambopy part 2 (GW calculations)]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
$ tar -xvf hBN-convergence-kpoints.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
$ cd $SCRATCH<br />
$ cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Modena 2025 : Yambopy part 2#Excitons| Modena 2025 : Yambopy part 2 (BSE calculations)]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
$ ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
* [[Prerequisites for Real Time propagation with Yambo (5.3)|Perform the setup for a real-time calculation]]<br />
* [[Dielectric function from Bloch-states dynamics (5.3)|Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN (5.3)|Second-harmonic generation of 2D-hBN]]<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [https://drive.google.com/file/d/1Z6GCjP4K1dM28ULsyYg2eckgUdYUSRph/view?usp=share_link First principles and data-driven correlated materials]<br />
* F. Mohamed, [https://drive.google.com/file/d/1ITddkGTM12Gw5QxnZjAQpfZgYH0FvJL1/view?usp=share_link A tour on Density Functional Theory]<br />
* E. Cannuccia, [https://drive.google.com/file/d/1mBTcPrnfoqwcA5wXE8gXQMO_qttClHAd/view?usp=share_link Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, [https://drive.google.com/file/d/1HTIPHkH2sBaVDLFwwS34T-fJ9x8FhVPq/view?usp=share_link Introduction to Many-Body Perturbation Theory]<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini, [https://drive.google.com/file/d/1dgcdHMfA0b7jjyrCs4r9OrG6qpiu1v39/view?usp=share_link GW in practice: algorithms and approximations]<br />
* G. Sesti, [https://drive.google.com/file/d/1te_85k9jgSymr3Av86rKOu0-tA-7sGWq/view?usp=sharing GW advanced algorithms]<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, [https://drive.google.com/file/d/1pQ491hqpETVLchL92QPy4f_jWqfMK5xf/view?usp=share_link Optical absorption and excitons via the Bethe-Salpeter Equation]<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8643Modena 20252025-05-17T09:28:58Z<p>Nicolaspallanzani: /* Connect to the cluster using ssh */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
<blockquote><br />
Be aware that when running the <code>ssh-copy-id</code> command, after typing "yes" at the prompt, you might see an error message like the one shown below. Don’t worry—just follow the instructions provided in this CINECA [https://wiki.u-gov.it/confluence/display/SCAIUS/FAQ#FAQ-Ikeepreceivingtheerrormessage%22WARNING:REMOTEHOSTIDENTIFICATIONHASCHANGED!%22evenifImodifyknown_hostfile guide to resolve the issue]. Once done, run the <code>ssh-copy-id</code> command again.<br />
</blockquote><br />
/usr/bin/ssh-copy-id: <br />
ERROR: @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@<br />
ERROR: @ WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! @<br />
ERROR: @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@<br />
ERROR: IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!<br />
[...]<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
ssh leonardo<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
#SBATCH --reservation=s_tra_yambo # Reservation specific to this school<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
<br />
Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resources]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh username R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hours:<br />
srun -A tra25_yambo -p dcgp_usr_prod --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command:<br />
exit<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first activate the python environment:<br />
module load profile/candidate<br />
module load python/3.11.7<br />
source /leonardo_work/tra25_yambo/env_yambopy/bin/activate<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
Since the compute nodes are not connected to the external network, the tarballs must be downloaded before starting the interactive session.<br />
Alternatively, once the interactive session has started, it is possible to access the tarballs by copying them from the following directories:<br />
<br />
/leonardo_work/tra25_yambo/YAMBO_TUTORIALS<br />
/leonardo_work/tra25_yambo/YAMBOPY_TUTORIALS<br />
<br />
After that you can start the interactive session<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
<br />
set the environment variable for openMP <br />
<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
and load yambo or yambopy as explained above in the general instructions.<br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN.tar.gz<br />
ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>srun</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
cd $SCRATCH<br />
mkdir -p YAMBOPY_TUTORIALS<br />
cd YAMBOPY_TUTORIALS<br />
wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar.gz<br />
tar -xvf databases_yambopy.tar.gz<br />
cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
tar -xvf hBN-convergence-kpoints.tar.gz<br />
tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
cd $SCRATCH<br />
cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8642Modena 20252025-05-17T09:24:58Z<p>Nicolaspallanzani: /* Use CINECA computational resources */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
<blockquote><br />
Be aware that when running the <code>ssh-copy-id</code> command, after typing "yes" at the prompt, you might see an error message like the one shown below. Don’t worry—just follow the instructions provided in this CINECA [https://wiki.u-gov.it/confluence/display/SCAIUS/FAQ#FAQ-Ikeepreceivingtheerrormessage%22WARNING:REMOTEHOSTIDENTIFICATIONHASCHANGED!%22evenifImodifyknown_hostfile guide to resolve the issue]. Once done, run the <code>ssh-copy-id</code> command again.<br />
</blockquote><br />
/usr/bin/ssh-copy-id: <br />
ERROR: @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@<br />
ERROR: @ WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! @<br />
ERROR: @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@<br />
ERROR: IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
ssh leonardo<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
#SBATCH --reservation=s_tra_yambo # Reservation specific to this school<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
<br />
Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resources]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh username R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hours:<br />
srun -A tra25_yambo -p dcgp_usr_prod --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command:<br />
exit<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first activate the python environment:<br />
module load profile/candidate<br />
module load python/3.11.7<br />
source /leonardo_work/tra25_yambo/env_yambopy/bin/activate<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
Since the compute nodes are not connected to the external network, the tarballs must be downloaded before starting the interactive session.<br />
Alternatively, once the interactive session has started, it is possible to access the tarballs by copying them from the following directories:<br />
<br />
/leonardo_work/tra25_yambo/YAMBO_TUTORIALS<br />
/leonardo_work/tra25_yambo/YAMBOPY_TUTORIALS<br />
<br />
After that you can start the interactive session<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
<br />
set the environment variable for openMP <br />
<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
and load yambo or yambopy as explained above in the general instructions.<br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN.tar.gz<br />
ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>srun</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
cd $SCRATCH<br />
mkdir -p YAMBOPY_TUTORIALS<br />
cd YAMBOPY_TUTORIALS<br />
wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar.gz<br />
tar -xvf databases_yambopy.tar.gz<br />
cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
tar -xvf hBN-convergence-kpoints.tar.gz<br />
tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
cd $SCRATCH<br />
cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8641Modena 20252025-05-17T09:21:18Z<p>Nicolaspallanzani: /* Connect to the cluster using ssh */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
<blockquote><br />
Be aware that when running the ssh-copy-id command, after typing yes at the prompt, you might see an error message like the one shown below. Don’t worry—just follow the instructions provided in this CINECA guide to resolve the issue. Once done, run the ssh-copy-id command again.<br />
</blockquote><br />
/usr/bin/ssh-copy-id: <br />
ERROR: @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@<br />
ERROR: @ WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! @<br />
ERROR: @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@<br />
ERROR: IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
ssh leonardo<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
#SBATCH --reservation=s_tra_yambo # Reservation specific to this school<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
<br />
Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resources]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh username R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hours:<br />
srun -A tra25_yambo -p dcgp_usr_prod --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command:<br />
exit<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first activate the python environment:<br />
module load profile/candidate<br />
module load python/3.11.7<br />
source /leonardo_work/tra25_yambo/env_yambopy/bin/activate<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
Since the compute nodes are not connected to the external network, the tarballs must be downloaded before starting the interactive session.<br />
Alternatively, once the interactive session has started, it is possible to access the tarballs by copying them from the following directories:<br />
<br />
/leonardo_work/tra25_yambo/YAMBO_TUTORIALS<br />
/leonardo_work/tra25_yambo/YAMBOPY_TUTORIALS<br />
<br />
After that you can start the interactive session<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
<br />
set the environment variable for openMP <br />
<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
and load yambo or yambopy as explained above in the general instructions.<br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN.tar.gz<br />
ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>srun</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
cd $SCRATCH<br />
mkdir -p YAMBOPY_TUTORIALS<br />
cd YAMBOPY_TUTORIALS<br />
wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar.gz<br />
tar -xvf databases_yambopy.tar.gz<br />
cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
tar -xvf hBN-convergence-kpoints.tar.gz<br />
tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
cd $SCRATCH<br />
cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8640Modena 20252025-05-17T08:58:03Z<p>Nicolaspallanzani: /* General instructions to run tutorials */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
ssh leonardo<br />
<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
#SBATCH --reservation=s_tra_yambo # Reservation specific to this school<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
<br />
Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resources]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh username R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hours:<br />
srun -A tra25_yambo -p dcgp_usr_prod --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command:<br />
exit<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first activate the python environment:<br />
module load profile/candidate<br />
module load python/3.11.7<br />
source /leonardo_work/tra25_yambo/env_yambopy/bin/activate<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
Since the compute nodes are not connected to the external network, the tarballs must be downloaded before starting the interactive session.<br />
Alternatively, once the interactive session has started, it is possible to access the tarballs by copying them from the following directories:<br />
<br />
/leonardo_work/tra25_yambo/YAMBO_TUTORIALS<br />
/leonardo_work/tra25_yambo/YAMBOPY_TUTORIALS<br />
<br />
After that you can start the interactive session<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
<br />
set the environment variable for openMP <br />
<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
and load yambo or yambopy as explained above in the general instructions.<br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN.tar.gz<br />
ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>srun</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
cd $SCRATCH<br />
mkdir -p YAMBOPY_TUTORIALS<br />
cd YAMBOPY_TUTORIALS<br />
wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar.gz<br />
tar -xvf databases_yambopy.tar.gz<br />
cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
tar -xvf hBN-convergence-kpoints.tar.gz<br />
tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
cd $SCRATCH<br />
cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8639Modena 20252025-05-17T08:57:11Z<p>Nicolaspallanzani: </p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
ssh leonardo<br />
<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
#SBATCH --reservation=s_tra_yambo # Reservation specific to this school<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
<br />
Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resources]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh username R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hours:<br />
srun -A tra25_yambo -p dcgp_usr_prod --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command:<br />
exit<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first activate the python environment:<br />
module load profile/candidate<br />
module load python/3.11.7<br />
source /leonardo_work/tra25_yambo/env_yambopy/bin/activate<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
Since the compute nodes are not connected to the external network, the tarballs must be downloaded before starting the interactive session.<br />
Alternatively, once the interactive session has started, it is possible to access the tarballs by copying them from the following directories:<br />
<br />
/leonardo_work/tra25_yambo/YAMBO_TUTORIALS<br />
/leonardo_work/tra25_yambo/YAMBOPY_TUTORIALS<br />
<br />
After that you can start the interactive session<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
<br />
set the environment variable for openMP <br />
<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
and load yambo or yambopy as explained above in the general instructions.<br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN.tar.gz<br />
ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>srun</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
cd $SCRATCH<br />
mkdir -p YAMBOPY_TUTORIALS<br />
cd YAMBOPY_TUTORIALS<br />
wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar.gz<br />
tar -xvf databases_yambopy.tar.gz<br />
cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
tar -xvf hBN-convergence-kpoints.tar.gz<br />
tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
cd $SCRATCH<br />
cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8637Modena 20252025-05-16T08:57:04Z<p>Nicolaspallanzani: /* General instructions to run tutorials */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
ssh leonardo<br />
<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
#SBATCH --reservation=s_tra_yambo # Reservation specific to this school<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resources]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh username R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hours:<br />
srun -A tra25_yambo -p dcgp_usr_prod --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command:<br />
exit<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first activate the python environment:<br />
module load profile/candidate<br />
module load python/3.11.7<br />
source /leonardo_work/tra25_yambo/env_yambopy/bin/activate<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
Since the compute nodes are not connected to the external network, the tarballs must be downloaded before starting the interactive session.<br />
Alternatively, once the interactive session has started, it is possible to access the tarballs by copying them from the following directories:<br />
<br />
/leonardo_work/tra25_yambo/YAMBO_TUTORIALS<br />
/leonardo_work/tra25_yambo/YAMBOPY_TUTORIALS<br />
<br />
After that you can start the interactive session<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS<br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN.tar.gz<br />
ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>srun</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
cd $SCRATCH<br />
mkdir -p YAMBOPY_TUTORIALS<br />
cd YAMBOPY_TUTORIALS<br />
wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar.gz<br />
tar -xvf databases_yambopy.tar.gz<br />
cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
tar -xvf hBN-convergence-kpoints.tar.gz<br />
tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
cd $SCRATCH<br />
cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8636Modena 20252025-05-16T08:54:54Z<p>Nicolaspallanzani: /* General instructions to run tutorials */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
ssh leonardo<br />
<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
#SBATCH --reservation=s_tra_yambo # Reservation specific to this school<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resources]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh username R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hours:<br />
srun -A tra25_yambo -p dcgp_usr_prod --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command:<br />
exit<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
cd<br />
module load anaconda3/2023.09-0<br />
conda init bash<br />
source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
module load profile/candidate<br />
module load python/3.11.7<br />
source /leonardo_work/tra25_yambo/env_yambopy/bin/activate<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
Since the compute nodes are not connected to the external network, the tarballs must be downloaded before starting the interactive session.<br />
Alternatively, once the interactive session has started, it is possible to access the tarballs by copying them from the following directories:<br />
<br />
/leonardo_work/tra25_yambo/YAMBO_TUTORIALS<br />
/leonardo_work/tra25_yambo/YAMBOPY_TUTORIALS<br />
<br />
After that you can start the interactive session<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS<br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN.tar.gz<br />
ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>srun</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
cd $SCRATCH<br />
mkdir -p YAMBOPY_TUTORIALS<br />
cd YAMBOPY_TUTORIALS<br />
wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar.gz<br />
tar -xvf databases_yambopy.tar.gz<br />
cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
tar -xvf hBN-convergence-kpoints.tar.gz<br />
tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
cd $SCRATCH<br />
cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8635Modena 20252025-05-15T14:29:12Z<p>Nicolaspallanzani: </p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
ssh leonardo<br />
<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
#SBATCH --reservation=s_tra_yambo # Reservation specific to this school<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resources]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh username R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hours:<br />
srun -A tra25_yambo -p dcgp_usr_prod --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command:<br />
exit<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
cd<br />
module load anaconda3/2023.09-0<br />
conda init bash<br />
source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
module load anaconda3/2023.09-0<br />
conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
Since the compute nodes are not connected to the external network, the tarballs must be downloaded before starting the interactive session.<br />
Alternatively, once the interactive session has started, it is possible to access the tarballs by copying them from the following directories:<br />
<br />
/leonardo_work/tra25_yambo/YAMBO_TUTORIALS<br />
/leonardo_work/tra25_yambo/YAMBOPY_TUTORIALS<br />
<br />
After that you can start the interactive session<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS<br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN.tar.gz<br />
ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>srun</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
cd $SCRATCH<br />
mkdir -p YAMBOPY_TUTORIALS<br />
cd YAMBOPY_TUTORIALS<br />
wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar.gz<br />
tar -xvf databases_yambopy.tar.gz<br />
cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
tar -xvf hBN-convergence-kpoints.tar.gz<br />
tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
cd $SCRATCH<br />
cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8634Modena 20252025-05-15T14:28:40Z<p>Nicolaspallanzani: </p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
ssh leonardo<br />
<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
#SBATCH --reservation=s_tra_yambo # Reservation specific to this school<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resources]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh username R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hours:<br />
srun -A tra25_yambo -p dcgp_usr_prod --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command:<br />
exit<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
cd<br />
module load anaconda3/2023.09-0<br />
conda init bash<br />
source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
module load anaconda3/2023.09-0<br />
conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
Since the compute nodes are not connected to the external network, the tarballs must be downloaded before starting the interactive session.<br />
Alternatively, once the interactive session has started, it is possible to access the tarballs by copying them from the following directories:<br />
<br />
/leonardo_work/tra25_yambo/YAMBO_TUTORIALS<br />
/leonardo_work/tra25_yambo/YAMBOPY_TUTORIALS<br />
<br />
After that you can start the interactive session<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS<br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN.tar.gz<br />
ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>srun</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
cd $SCRATCH<br />
mkdir -p YAMBOPY_TUTORIALS<br />
cd YAMBOPY_TUTORIALS<br />
wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar.gz<br />
tar -xvf databases_yambopy.tar.gz<br />
cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
tar -xvf hBN-convergence-kpoints.tar.gz<br />
tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
cd $SCRATCH<br />
cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8633Modena 20252025-05-15T08:15:51Z<p>Nicolaspallanzani: /* General instructions to run tutorials */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
ssh leonardo<br />
<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
#SBATCH --reservation=s_tra_yambo # Reservation specific to this school<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resources]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh username R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hours:<br />
srun -A tra25_yambo -p dcgp_usr_prod --reservation=s_tra_yambo -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command:<br />
exit<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
cd<br />
module load anaconda3/2023.09-0<br />
conda init bash<br />
source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
module load anaconda3/2023.09-0<br />
conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
Since the compute nodes are not connected to the external network, the tarballs must be downloaded before starting the interactive session.<br />
Alternatively, once the interactive session has started, it is possible to access the tarballs by copying them from the following directories:<br />
<br />
/leonardo_work/tra25_yambo/YAMBO_TUTORIALS<br />
/leonardo_work/tra25_yambo/YAMBOPY_TUTORIALS<br />
<br />
After that you can start the interactive session<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal --reservation=TBD -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS<br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN.tar.gz<br />
ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>srun</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
cd $SCRATCH<br />
mkdir -p YAMBOPY_TUTORIALS<br />
cd YAMBOPY_TUTORIALS<br />
wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar.gz<br />
tar -xvf databases_yambopy.tar.gz<br />
cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
tar -xvf hBN-convergence-kpoints.tar.gz<br />
tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
cd $SCRATCH<br />
cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8629Modena 20252025-05-14T14:39:47Z<p>Nicolaspallanzani: /* General instructions to run tutorials */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
ssh leonardo<br />
<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=TBD # Reservation specific to this school<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal --reservation=TBD -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command:<br />
exit<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
cd<br />
module load anaconda3/2023.09-0<br />
conda init bash<br />
source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
module load anaconda3/2023.09-0<br />
conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
Since the compute nodes are not connected to the external network, the tarballs must be downloaded before starting the interactive session.<br />
Alternatively, once the interactive session has started, it is possible to access the tarballs by copying them from the following directories:<br />
<br />
/leonardo_work/tra25_yambo/YAMBO_TUTORIALS<br />
/leonardo_work/tra25_yambo/YAMBOPY_TUTORIALS<br />
<br />
After that you can start the interactive session<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal --reservation=TBD -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS<br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN.tar.gz<br />
ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>srun</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
cd $SCRATCH<br />
mkdir -p YAMBOPY_TUTORIALS<br />
cd YAMBOPY_TUTORIALS<br />
wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar.gz<br />
tar -xvf databases_yambopy.tar.gz<br />
cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
tar -xvf hBN-convergence-kpoints.tar.gz<br />
tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
cd $SCRATCH<br />
cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8628Modena 20252025-05-14T14:39:16Z<p>Nicolaspallanzani: </p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
ssh leonardo<br />
<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
$ cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=TBD # Reservation specific to this school<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal --reservation=TBD -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command:<br />
exit<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
cd<br />
module load anaconda3/2023.09-0<br />
conda init bash<br />
source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
module load anaconda3/2023.09-0<br />
conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
Since the compute nodes are not connected to the external network, the tarballs must be downloaded before starting the interactive session.<br />
Alternatively, once the interactive session has started, it is possible to access the tarballs by copying them from the following directories:<br />
<br />
/leonardo_work/tra25_yambo/YAMBO_TUTORIALS<br />
/leonardo_work/tra25_yambo/YAMBOPY_TUTORIALS<br />
<br />
After that you can start the interactive session<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal --reservation=TBD -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS<br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN.tar.gz<br />
ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>srun</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
cd $SCRATCH<br />
mkdir -p YAMBOPY_TUTORIALS<br />
cd YAMBOPY_TUTORIALS<br />
wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar.gz<br />
tar -xvf databases_yambopy.tar.gz<br />
cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
tar -xvf hBN-convergence-kpoints.tar.gz<br />
tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
cd $SCRATCH<br />
cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8627Modena 20252025-05-14T14:35:47Z<p>Nicolaspallanzani: /* Tutorials */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
$ ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
$ ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
$ ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
$ ssh leonardo<br />
<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
$ cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=TBD # Reservation specific to this school<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
$ sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
$ squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
$ scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
$ srun -A tra25_yambo -p dcgp_usr_prod -q normal --reservation=TBD -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
$ module purge<br />
$ module load profile/candidate<br />
$ module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
$ export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command, and then cancel the job:<br />
$ exit<br />
$ scancel <JOBID><br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
$ ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
$ cd<br />
$ module load anaconda3/2023.09-0<br />
$ conda init bash<br />
$ source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
$ module load anaconda3/2023.09-0<br />
$ conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
Since the compute nodes are not connected to the external network, the tarballs must be downloaded before starting the interactive session.<br />
Alternatively, once the interactive session has started, it is possible to access the tarballs by copying them from the following directories:<br />
<br />
/leonardo_work/tra25_yambo/YAMBO_TUTORIALS<br />
/leonardo_work/tra25_yambo/YAMBOPY_TUTORIALS<br />
<br />
After that you can start the interactive session<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal --reservation=TBD -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS<br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN.tar.gz<br />
ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>srun</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
cd $SCRATCH<br />
mkdir -p YAMBOPY_TUTORIALS<br />
cd YAMBOPY_TUTORIALS<br />
wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar.gz<br />
tar -xvf databases_yambopy.tar.gz<br />
cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
tar -xvf hBN-convergence-kpoints.tar.gz<br />
tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
cd $SCRATCH<br />
cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
tar -xvf hBN-2D.tar.gz<br />
tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8626Modena 20252025-05-14T13:34:38Z<p>Nicolaspallanzani: /* DAY 1 - Monday, 19 May */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
$ ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
$ ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
$ ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
$ ssh leonardo<br />
<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
$ cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=TBD # Reservation specific to this school<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
$ sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
$ squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
$ scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
$ srun -A tra25_yambo -p dcgp_usr_prod -q normal --reservation=TBD -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
$ module purge<br />
$ module load profile/candidate<br />
$ module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
$ export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command, and then cancel the job:<br />
$ exit<br />
$ scancel <JOBID><br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
$ ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
$ cd<br />
$ module load anaconda3/2023.09-0<br />
$ conda init bash<br />
$ source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
$ module load anaconda3/2023.09-0<br />
$ conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
At this point you can download the needed files for the tutorial.<br />
After that you can open the interactive session and login into the node<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal --reservation=TBD -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS <br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>srun</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
$ cd $SCRATCH<br />
$ mkdir -p YAMBOPY_TUTORIALS<br />
$ cd YAMBOPY_TUTORIALS<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar.gz<br />
$ tar -xvf databases_yambopy.tar.gz<br />
$ cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
$ tar -xvf hBN-convergence-kpoints.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
$ cd $SCRATCH<br />
$ cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
$ ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8625Modena 20252025-05-14T12:52:51Z<p>Nicolaspallanzani: /* DAY 1 - Monday, 19 May */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
$ ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
$ ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
$ ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
$ ssh leonardo<br />
<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
$ cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=TBD # Reservation specific to this school<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
$ sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
$ squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
$ scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
$ srun -A tra25_yambo -p dcgp_usr_prod -q normal --reservation=TBD -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
$ module purge<br />
$ module load profile/candidate<br />
$ module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
$ export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command, and then cancel the job:<br />
$ exit<br />
$ scancel <JOBID><br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
$ ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
$ cd<br />
$ module load anaconda3/2023.09-0<br />
$ conda init bash<br />
$ source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
$ module load anaconda3/2023.09-0<br />
$ conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
At this point you can download the needed files for the tutorial.<br />
After that you can open the interactive session and login into the node<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal --reservation=TBD -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS <br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>srun</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
$ cd $SCRATCH<br />
$ mkdir -p YAMBOPY_TUTORIALS<br />
$ cd YAMBOPY_TUTORIALS<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar<br />
$ tar -xvf databases_yambopy.tar<br />
$ cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
$ tar -xvf hBN-convergence-kpoints.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
$ cd $SCRATCH<br />
$ cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
$ ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8624Modena 20252025-05-13T10:19:40Z<p>Nicolaspallanzani: </p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
$ ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
$ ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
$ ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
$ ssh leonardo<br />
<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
$ cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=TBD # Reservation specific to this school<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
$ sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
$ squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
$ scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
$ srun -A tra25_yambo -p dcgp_usr_prod -q normal --reservation=TBD -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
$ module purge<br />
$ module load profile/candidate<br />
$ module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
$ export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command, and then cancel the job:<br />
$ exit<br />
$ scancel <JOBID><br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
$ ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
$ cd<br />
$ module load anaconda3/2023.09-0<br />
$ conda init bash<br />
$ source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
$ module load anaconda3/2023.09-0<br />
$ conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
At this point you can download the needed files for the tutorial.<br />
After that you can open the interactive session and login into the node<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal --reservation=TBD -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS <br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>salloc</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
$ cd $SCRATCH<br />
$ mkdir -p YAMBOPY_TUTORIALS<br />
$ cd YAMBOPY_TUTORIALS<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar<br />
$ tar -xvf databases_yambopy.tar<br />
$ cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
$ tar -xvf hBN-convergence-kpoints.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
$ cd $SCRATCH<br />
$ cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
$ ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8623Modena 20252025-05-13T09:35:57Z<p>Nicolaspallanzani: </p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
$ ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
$ ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
$ ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
$ ssh leonardo<br />
<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
$ cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=s_tra_yambo # Reservation specific to this school (TBD) !!!!!!!!!<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
$ sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
$ squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
$ scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
$ srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
$ module purge<br />
$ module load profile/candidate<br />
$ module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
$ export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command, and then cancel the job:<br />
$ exit<br />
$ scancel <JOBID><br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
$ ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
$ cd<br />
$ module load anaconda3/2023.09-0<br />
$ conda init bash<br />
$ source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
$ module load anaconda3/2023.09-0<br />
$ conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
At this point you can download the needed files for the tutorial.<br />
After that you can open the interactive session and login into the node<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS <br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>salloc</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
$ cd $SCRATCH<br />
$ mkdir -p YAMBOPY_TUTORIALS<br />
$ cd YAMBOPY_TUTORIALS<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar<br />
$ tar -xvf databases_yambopy.tar<br />
$ cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
$ tar -xvf hBN-convergence-kpoints.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
$ cd $SCRATCH<br />
$ cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
$ ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8622Modena 20252025-05-13T09:34:25Z<p>Nicolaspallanzani: /* Use CINECA computational resources */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
$ ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
$ ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
$ ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
$ ssh leonardo<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
$ cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=s_tra_yambo # Reservation specific to this school (TBD) !!!!!!!!!<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
$ sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
$ squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
$ scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
$ srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
$ module purge<br />
$ module load profile/candidate<br />
$ module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
$ export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command, and then cancel the job:<br />
$ exit<br />
$ scancel <JOBID><br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
$ ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
$ cd<br />
$ module load anaconda3/2023.09-0<br />
$ conda init bash<br />
$ source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
$ module load anaconda3/2023.09-0<br />
$ conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
At this point you can download the needed files for the tutorial.<br />
After that you can open the interactive session and login into the node<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS <br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>salloc</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
$ cd $SCRATCH<br />
$ mkdir -p YAMBOPY_TUTORIALS<br />
$ cd YAMBOPY_TUTORIALS<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar<br />
$ tar -xvf databases_yambopy.tar<br />
$ cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
$ tar -xvf hBN-convergence-kpoints.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
$ cd $SCRATCH<br />
$ cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
$ ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8621Modena 20252025-05-13T09:33:01Z<p>Nicolaspallanzani: /* Use CINECA computational resources */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
$ ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
$ ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
$ ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
$ ssh leonardo<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
$ cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=s_tra_yambo # Reservation specific to this school (TBD) !!!!!!!!!<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
$ sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
$ squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
$ scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
$ srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
$ module purge<br />
$ module load profile/candidate<br />
$ module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
$ export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command, and then cancel the job:<br />
$ exit<br />
$ scancel <JOBID><br />
<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
$ ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
$ cd<br />
$ module load anaconda3/2023.09-0<br />
$ conda init bash<br />
$ source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
$ module load anaconda3/2023.09-0<br />
$ conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
At this point you can download the needed files for the tutorial.<br />
After that you can open the interactive session and login into the node<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS <br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>salloc</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
$ cd $SCRATCH<br />
$ mkdir -p YAMBOPY_TUTORIALS<br />
$ cd YAMBOPY_TUTORIALS<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar<br />
$ tar -xvf databases_yambopy.tar<br />
$ cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
$ tar -xvf hBN-convergence-kpoints.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
$ cd $SCRATCH<br />
$ cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
$ ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8620Modena 20252025-05-13T09:32:21Z<p>Nicolaspallanzani: /* Use CINECA computational resources */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
$ ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
$ ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
$ ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
$ ssh leonardo<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
$ cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=s_tra_yambo # Reservation specific to this school (TBD) !!!!!!!!!<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
$ sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
$ squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
$ scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
$ srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
$ module purge<br />
$ module load profile/candidate<br />
$ module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
$ export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command, and then cancel the job:<br />
$ exit<br />
$ scancel <JOBID><br />
<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
$ ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
$ cd<br />
$ module load anaconda3/2023.09-0<br />
$ conda init bash<br />
$ source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
$ module load anaconda3/2023.09-0<br />
$ conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
At this point you can download the needed files for the tutorial.<br />
After that you can open the interactive session and login into the node<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS <br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>salloc</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
$ cd $SCRATCH<br />
$ mkdir -p YAMBOPY_TUTORIALS<br />
$ cd YAMBOPY_TUTORIALS<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar<br />
$ tar -xvf databases_yambopy.tar<br />
$ cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
$ tar -xvf hBN-convergence-kpoints.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
$ cd $SCRATCH<br />
$ cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
$ ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8618Modena 20252025-05-13T09:25:27Z<p>Nicolaspallanzani: /* Use CINECA computational resources */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP partition. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
$ ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
$ ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
$ ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
$ ssh leonardo<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
$ cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=s_tra_yambo # Reservation specific to this school (TBD) !!!!!!!!!<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
$ sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
$ squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
$ scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
$ srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
$ module purge<br />
$ module load profile/candidate<br />
$ module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
$ export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command, and then cancel the job:<br />
$ exit<br />
$ scancel <JOBID><br />
<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
$ ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
$ cd<br />
$ module load anaconda3/2023.09-0<br />
$ conda init bash<br />
$ source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
$ module load anaconda3/2023.09-0<br />
$ conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
At this point you can download the needed files for the tutorial.<br />
After that you can open the interactive session and login into the node<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS <br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>salloc</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
$ cd $SCRATCH<br />
$ mkdir -p YAMBOPY_TUTORIALS<br />
$ cd YAMBOPY_TUTORIALS<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar<br />
$ tar -xvf databases_yambopy.tar<br />
$ cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
$ tar -xvf hBN-convergence-kpoints.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
$ cd $SCRATCH<br />
$ cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
$ ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8617Modena 20252025-05-13T09:25:02Z<p>Nicolaspallanzani: /* Connect to the cluster using ssh */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
$ ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
$ ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
$ ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
$ ssh leonardo<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
$ cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=s_tra_yambo # Reservation specific to this school (TBD) !!!!!!!!!<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
$ sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
$ squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
$ scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
$ srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
$ module purge<br />
$ module load profile/candidate<br />
$ module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
$ export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command, and then cancel the job:<br />
$ exit<br />
$ scancel <JOBID><br />
<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
$ ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
$ cd<br />
$ module load anaconda3/2023.09-0<br />
$ conda init bash<br />
$ source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
$ module load anaconda3/2023.09-0<br />
$ conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
At this point you can download the needed files for the tutorial.<br />
After that you can open the interactive session and login into the node<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS <br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>salloc</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
$ cd $SCRATCH<br />
$ mkdir -p YAMBOPY_TUTORIALS<br />
$ cd YAMBOPY_TUTORIALS<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar<br />
$ tar -xvf databases_yambopy.tar<br />
$ cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
$ tar -xvf hBN-convergence-kpoints.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
$ cd $SCRATCH<br />
$ cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
$ ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8616Modena 20252025-05-13T09:24:46Z<p>Nicolaspallanzani: </p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo-DCGP via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
$ ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
$ ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
$ ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
$ ssh leonardo<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
$ cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=s_tra_yambo # Reservation specific to this school (TBD) !!!!!!!!!<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
$ sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
$ squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
$ scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
$ srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
$ module purge<br />
$ module load profile/candidate<br />
$ module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
$ export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command, and then cancel the job:<br />
$ exit<br />
$ scancel <JOBID><br />
<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
$ ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
$ cd<br />
$ module load anaconda3/2023.09-0<br />
$ conda init bash<br />
$ source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
$ module load anaconda3/2023.09-0<br />
$ conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
At this point you can download the needed files for the tutorial.<br />
After that you can open the interactive session and login into the node<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS <br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>salloc</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
$ cd $SCRATCH<br />
$ mkdir -p YAMBOPY_TUTORIALS<br />
$ cd YAMBOPY_TUTORIALS<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar<br />
$ tar -xvf databases_yambopy.tar<br />
$ cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
$ tar -xvf hBN-convergence-kpoints.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
$ cd $SCRATCH<br />
$ cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
$ ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8615Modena 20252025-05-13T09:23:18Z<p>Nicolaspallanzani: /* DAY 1 - Monday, 19 May */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo-DCGP via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
$ ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
$ ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
$ ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
$ ssh leonardo<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
$ cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=s_tra_yambo # Reservation specific to this school (TBD) !!!!!!!!!<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
$ sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
$ squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
$ scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
$ srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
$ module purge<br />
$ module load profile/candidate<br />
$ module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
$ export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command, and then cancel the job:<br />
$ exit<br />
$ scancel <JOBID><br />
<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
$ ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
$ cd<br />
$ module load anaconda3/2023.09-0<br />
$ conda init bash<br />
$ source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
$ module load anaconda3/2023.09-0<br />
$ conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
At this point you can download the needed files for the tutorial.<br />
After that you can open the interactive session and login into the node<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS <br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>salloc</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
$ cd $CINECA_SCRATCH<br />
$ mkdir -p YAMBOPY_TUTORIALS<br />
$ cd YAMBOPY_TUTORIALS<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar<br />
$ tar -xvf databases_yambopy.tar<br />
$ cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $CINECA_SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
$ tar -xvf hBN-convergence-kpoints.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
$ cd $CINECA_SCRATCH<br />
$ cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
$ ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8614Modena 20252025-05-13T09:21:14Z<p>Nicolaspallanzani: /* Connect to the cluster using ssh */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo-DCGP via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
$ ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
$ ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
$ ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
$ ssh leonardo<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
$ cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=s_tra_yambo # Reservation specific to this school (TBD) !!!!!!!!!<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
$ sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
$ squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
$ scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
$ srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
$ module purge<br />
$ module load profile/candidate<br />
$ module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
$ export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command, and then cancel the job:<br />
$ exit<br />
$ scancel <JOBID><br />
<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
$ ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
$ cd<br />
$ module load anaconda3/2023.09-0<br />
$ conda init bash<br />
$ source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
$ module load anaconda3/2023.09-0<br />
$ conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
At this point you can download the needed files for the tutorial.<br />
After that you can open the interactive session and login into the node<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS <br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>salloc</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
$ cd $CINECA_SCRATCH<br />
$ mkdir YAMBOPY_TUTORIALS<br />
$ cd YAMBOPY_TUTORIALS<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar<br />
$ tar -xvf databases_yambopy.tar<br />
$ cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $CINECA_SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
$ tar -xvf hBN-convergence-kpoints.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
$ cd $CINECA_SCRATCH<br />
$ cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
$ ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8613Modena 20252025-05-13T09:18:32Z<p>Nicolaspallanzani: /* Tutorials */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo-DCGP via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
$ ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
'''FROM HERE IS A PLACEHOLDER: NICOLA WILL FILL THIS PART'''<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
$ ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
$ ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
$ ssh leonardo<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
$ cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=s_tra_yambo # Reservation specific to this school (TBD) !!!!!!!!!<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
$ sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
$ squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
$ scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
$ srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
$ module purge<br />
$ module load profile/candidate<br />
$ module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
$ export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command, and then cancel the job:<br />
$ exit<br />
$ scancel <JOBID><br />
<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
$ ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
$ cd<br />
$ module load anaconda3/2023.09-0<br />
$ conda init bash<br />
$ source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
$ module load anaconda3/2023.09-0<br />
$ conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir -p YAMBO_TUTORIALS '''#(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
At this point you can download the needed files for the tutorial.<br />
After that you can open the interactive session and login into the node<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS <br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>salloc</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
$ cd $CINECA_SCRATCH<br />
$ mkdir YAMBOPY_TUTORIALS<br />
$ cd YAMBOPY_TUTORIALS<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar<br />
$ tar -xvf databases_yambopy.tar<br />
$ cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $CINECA_SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
$ tar -xvf hBN-convergence-kpoints.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
$ cd $CINECA_SCRATCH<br />
$ cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
$ ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8612Modena 20252025-05-13T09:16:05Z<p>Nicolaspallanzani: /* Tutorials */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo-DCGP via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
$ ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
'''FROM HERE IS A PLACEHOLDER: NICOLA WILL FILL THIS PART'''<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
$ ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
$ ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
$ ssh leonardo<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
$ cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=s_tra_yambo # Reservation specific to this school (TBD) !!!!!!!!!<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
$ sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
$ squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
$ scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
$ srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
$ module purge<br />
$ module load profile/candidate<br />
$ module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
$ export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command, and then cancel the job:<br />
$ exit<br />
$ scancel <JOBID><br />
<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
$ ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
$ cd<br />
$ module load anaconda3/2023.09-0<br />
$ conda init bash<br />
$ source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
$ module load anaconda3/2023.09-0<br />
$ conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on Leonardo, do the following steps<br />
<br />
ssh leonardo<br />
cd $SCRATCH<br />
mkdir YAMBO_TUTORIALS '''(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
At this point you can download the needed files for the tutorial.<br />
After that you can open the interactive session and login into the node<br />
<br />
srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
[...]<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
cd $SCRATCH/YAMBO_TUTORIALS <br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>salloc</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
$ cd $CINECA_SCRATCH<br />
$ mkdir YAMBOPY_TUTORIALS<br />
$ cd YAMBOPY_TUTORIALS<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar<br />
$ tar -xvf databases_yambopy.tar<br />
$ cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $CINECA_SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
$ tar -xvf hBN-convergence-kpoints.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
$ cd $CINECA_SCRATCH<br />
$ cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
$ ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8610Modena 20252025-05-13T09:11:37Z<p>Nicolaspallanzani: /* General instructions to run tutorials */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo-DCGP via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
$ ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
'''FROM HERE IS A PLACEHOLDER: NICOLA WILL FILL THIS PART'''<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
$ ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
$ ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
$ ssh leonardo<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on Leonardo, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/4%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
$ cd $SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=s_tra_yambo # Reservation specific to this school (TBD) !!!!!!!!!<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
$ sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
$ squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
$ scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
$ srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
$ module purge<br />
$ module load profile/candidate<br />
$ module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
$ export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command, and then cancel the job:<br />
$ exit<br />
$ scancel <JOBID><br />
<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on Leonardo, '''open a new terminal window''' and connect to Leonardo enabling X11 forwarding with the <code>-X</code> option:<br />
$ ssh -X leonardo<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on Leonardo, you must first setup the conda environment (to be done only once):<br />
$ cd<br />
$ module load anaconda3/2023.09-0<br />
$ conda init bash<br />
$ source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
$ module load anaconda3/2023.09-0<br />
$ conda activate !!!!!!!! TBD !!!!!!!!<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on m100, do the following steps<br />
<br />
ssh m100<br />
cd $CINECA_SCRATCH<br />
mkdir YAMBO_TUTORIALS '''(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
At this point you can download the needed files for the tutorial.<br />
After that you can open the interactive session and login into the node<br />
<br />
salloc -A tra23_Yambo -p m100_sys_test -q qos_test --reservation=s_tra_yambo --nodes=1 --ntasks-per-node=1 --cpus-per-task=4 -t 04:00:00<br />
ssh '''PUT HERE THE ASSIGNED NODE NAME AFTER salloc COMMAND'''<br />
module purge<br />
module load hpc-sdk/2022--binary spectrum_mpi/10.4.0--binary<br />
export PATH=/m100_work/tra23_Yambo/softwares/YAMBO/5.2-cpu/bin:$PATH<br />
cd $CINECA_SCRATCH<br />
cd YAMBO_TUTORIALS <br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>salloc</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
$ cd $CINECA_SCRATCH<br />
$ mkdir YAMBOPY_TUTORIALS<br />
$ cd YAMBOPY_TUTORIALS<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar<br />
$ tar -xvf databases_yambopy.tar<br />
$ cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $CINECA_SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
$ tar -xvf hBN-convergence-kpoints.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
$ cd $CINECA_SCRATCH<br />
$ cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
$ ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8609Modena 20252025-05-13T09:05:17Z<p>Nicolaspallanzani: /* Connect to the cluster using ssh */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo-DCGP via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
$ ssh username@login.leonardo.cineca.it<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
'''FROM HERE IS A PLACEHOLDER: NICOLA WILL FILL THIS PART'''<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to Leonardo. To do so, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/leonardo_rsa<br />
Generating public/private rsa key pair.<br />
Created directory '/home/username/.ssh'.<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in /home/username/.ssh/leonardo_rsa<br />
Your public key has been saved in /home/username/.ssh/leonardo_rsa.pub<br />
The key fingerprint is:<br />
[...]<br />
The key's randomart image is:<br />
[...]<br />
<br />
<br />
Now you need to copy the '''public''' key to Leonardo. You can do that with the following command (for this step you need to type your password):<br />
$ ssh-copy-id -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
Once the public key has been copied, you can connect to Leonardo without having to type the password using the <code>-i</code> option:<br />
$ ssh -i ~/.ssh/leonardo_rsa username@login.leonardo.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting the username:<br />
Host leonardo <br />
HostName login.leonardo.cineca.it<br />
User username<br />
IdentityFile ~/.ssh/leonardo_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
$ ssh leonardo<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on M100, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$CINECA_SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/UG2.5%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $CINECA_SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
$ cd $CINECA_SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=s_tra_yambo # Reservation specific to this school (TBD)<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
$ sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
$ squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
$ scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
$ srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
$ module purge<br />
$ module load profile/candidate<br />
$ module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
$ export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command, and then cancel the job:<br />
$ exit<br />
$ scancel <JOBID><br />
<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on M100, '''open a new terminal window''' and connect to M100 enabling X11 forwarding with the <code>-X</code> option:<br />
$ ssh -X m100<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on m100, you must first setup the conda environment (to be done only once):<br />
$ cd<br />
$ module load anaconda/2020.11<br />
$ conda init bash<br />
$ source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
$ module load anaconda/2020.11<br />
$ conda activate /m100_work/tra23_Yambo/softwares/YAMBO/env_yambopy<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on m100, do the following steps<br />
<br />
ssh m100<br />
cd $CINECA_SCRATCH<br />
mkdir YAMBO_TUTORIALS '''(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
At this point you can download the needed files for the tutorial.<br />
After that you can open the interactive session and login into the node<br />
<br />
salloc -A tra23_Yambo -p m100_sys_test -q qos_test --reservation=s_tra_yambo --nodes=1 --ntasks-per-node=1 --cpus-per-task=4 -t 04:00:00<br />
ssh '''PUT HERE THE ASSIGNED NODE NAME AFTER salloc COMMAND'''<br />
module purge<br />
module load hpc-sdk/2022--binary spectrum_mpi/10.4.0--binary<br />
export PATH=/m100_work/tra23_Yambo/softwares/YAMBO/5.2-cpu/bin:$PATH<br />
cd $CINECA_SCRATCH<br />
cd YAMBO_TUTORIALS <br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>salloc</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
$ cd $CINECA_SCRATCH<br />
$ mkdir YAMBOPY_TUTORIALS<br />
$ cd YAMBOPY_TUTORIALS<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar<br />
$ tar -xvf databases_yambopy.tar<br />
$ cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $CINECA_SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
$ tar -xvf hBN-convergence-kpoints.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
$ cd $CINECA_SCRATCH<br />
$ cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
$ ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8608Modena 20252025-05-13T08:34:52Z<p>Nicolaspallanzani: /* General instructions to run tutorials */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo-DCGP via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
$ ssh ...<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
'''FROM HERE IS A PLACEHOLDER: NICOLA WILL FILL THIS PART'''<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to M100. To do so, go to your <code>.ssh</code> directory (usually located in the <code>home</code> directory):<br />
$ cd $HOME/.ssh<br />
<br />
If you don't have this directory, you can create it with <code>mkdir $HOME/.ssh</code>.<br />
<br />
Once you are in the <code>.ssh</code> directory, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
$ ssh-keygen<br />
Generating public/private rsa key pair.<br />
Enter file in which to save the key: m100_id_rsa<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in <your_.ssh_dir>/m100_id_rsa<br />
Your public key has been saved in <your_.ssh_dir>/m100_id_rsa.pub<br />
The key fingerprint is:<br />
<...><br />
The key's randomart image is:<br />
<...><br />
<br />
Now you need to copy the '''public''' key to M100. You can do that with the following command (for this step you need to type your password):<br />
$ ssh-copy-id -i <your_.ssh_dir>/m100_id_rsa.pub <username>@login.m100.cineca.it<br />
<br />
Once the public key has been copied, you can connect to M100 without having to type the password using the <code>-i</code> option:<br />
$ ssh -i <your_.ssh_dir>/m100_id_rsa username@login.m100.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting username and path:<br />
Host m100 <br />
HostName login.m100.cineca.it<br />
User username<br />
IdentityFile <your_.ssh_dir>/m100_id_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
$ ssh m100<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on M100, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$CINECA_SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/UG2.5%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $CINECA_SCRATCH<br />
/leonardo_scratch/large/userexternal/username<br />
$ cd $CINECA_SCRATCH<br />
<br />
Computational resources on Leonardo are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=s_tra_yambo # Reservation specific to this school (TBD)<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
$ sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
$ squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
$ scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
$ srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
$ module purge<br />
$ module load profile/candidate<br />
$ module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
$ export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command, and then cancel the job:<br />
$ exit<br />
$ scancel <JOBID><br />
<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on M100, '''open a new terminal window''' and connect to M100 enabling X11 forwarding with the <code>-X</code> option:<br />
$ ssh -X m100<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on m100, you must first setup the conda environment (to be done only once):<br />
$ cd<br />
$ module load anaconda/2020.11<br />
$ conda init bash<br />
$ source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
$ module load anaconda/2020.11<br />
$ conda activate /m100_work/tra23_Yambo/softwares/YAMBO/env_yambopy<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on m100, do the following steps<br />
<br />
ssh m100<br />
cd $CINECA_SCRATCH<br />
mkdir YAMBO_TUTORIALS '''(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
At this point you can download the needed files for the tutorial.<br />
After that you can open the interactive session and login into the node<br />
<br />
salloc -A tra23_Yambo -p m100_sys_test -q qos_test --reservation=s_tra_yambo --nodes=1 --ntasks-per-node=1 --cpus-per-task=4 -t 04:00:00<br />
ssh '''PUT HERE THE ASSIGNED NODE NAME AFTER salloc COMMAND'''<br />
module purge<br />
module load hpc-sdk/2022--binary spectrum_mpi/10.4.0--binary<br />
export PATH=/m100_work/tra23_Yambo/softwares/YAMBO/5.2-cpu/bin:$PATH<br />
cd $CINECA_SCRATCH<br />
cd YAMBO_TUTORIALS <br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>salloc</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
$ cd $CINECA_SCRATCH<br />
$ mkdir YAMBOPY_TUTORIALS<br />
$ cd YAMBOPY_TUTORIALS<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar<br />
$ tar -xvf databases_yambopy.tar<br />
$ cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $CINECA_SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
$ tar -xvf hBN-convergence-kpoints.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
$ cd $CINECA_SCRATCH<br />
$ cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
$ ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8607Modena 20252025-05-13T08:33:20Z<p>Nicolaspallanzani: /* General instructions to run tutorials */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo-DCGP via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
$ ssh ...<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
'''FROM HERE IS A PLACEHOLDER: NICOLA WILL FILL THIS PART'''<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to M100. To do so, go to your <code>.ssh</code> directory (usually located in the <code>home</code> directory):<br />
$ cd $HOME/.ssh<br />
<br />
If you don't have this directory, you can create it with <code>mkdir $HOME/.ssh</code>.<br />
<br />
Once you are in the <code>.ssh</code> directory, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
$ ssh-keygen<br />
Generating public/private rsa key pair.<br />
Enter file in which to save the key: m100_id_rsa<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in <your_.ssh_dir>/m100_id_rsa<br />
Your public key has been saved in <your_.ssh_dir>/m100_id_rsa.pub<br />
The key fingerprint is:<br />
<...><br />
The key's randomart image is:<br />
<...><br />
<br />
Now you need to copy the '''public''' key to M100. You can do that with the following command (for this step you need to type your password):<br />
$ ssh-copy-id -i <your_.ssh_dir>/m100_id_rsa.pub <username>@login.m100.cineca.it<br />
<br />
Once the public key has been copied, you can connect to M100 without having to type the password using the <code>-i</code> option:<br />
$ ssh -i <your_.ssh_dir>/m100_id_rsa username@login.m100.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting username and path:<br />
Host m100 <br />
HostName login.m100.cineca.it<br />
User username<br />
IdentityFile <your_.ssh_dir>/m100_id_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
$ ssh m100<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on M100, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$CINECA_SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/UG2.5%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $CINECA_SCRATCH<br />
/m100_scratch/userexternal/username<br />
$ cd $CINECA_SCRATCH<br />
<br />
Computational resources on M100 are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=s_tra_yambo # Reservation specific to this school (TBD)<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
$ sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
$ squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
$ scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
$ srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
$ module purge<br />
$ module load profile/candidate<br />
$ module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
$ export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command, and then cancel the job:<br />
$ exit<br />
$ scancel <JOBID><br />
<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on M100, '''open a new terminal window''' and connect to M100 enabling X11 forwarding with the <code>-X</code> option:<br />
$ ssh -X m100<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on m100, you must first setup the conda environment (to be done only once):<br />
$ cd<br />
$ module load anaconda/2020.11<br />
$ conda init bash<br />
$ source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
$ module load anaconda/2020.11<br />
$ conda activate /m100_work/tra23_Yambo/softwares/YAMBO/env_yambopy<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on m100, do the following steps<br />
<br />
ssh m100<br />
cd $CINECA_SCRATCH<br />
mkdir YAMBO_TUTORIALS '''(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
At this point you can download the needed files for the tutorial.<br />
After that you can open the interactive session and login into the node<br />
<br />
salloc -A tra23_Yambo -p m100_sys_test -q qos_test --reservation=s_tra_yambo --nodes=1 --ntasks-per-node=1 --cpus-per-task=4 -t 04:00:00<br />
ssh '''PUT HERE THE ASSIGNED NODE NAME AFTER salloc COMMAND'''<br />
module purge<br />
module load hpc-sdk/2022--binary spectrum_mpi/10.4.0--binary<br />
export PATH=/m100_work/tra23_Yambo/softwares/YAMBO/5.2-cpu/bin:$PATH<br />
cd $CINECA_SCRATCH<br />
cd YAMBO_TUTORIALS <br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>salloc</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
$ cd $CINECA_SCRATCH<br />
$ mkdir YAMBOPY_TUTORIALS<br />
$ cd YAMBOPY_TUTORIALS<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar<br />
$ tar -xvf databases_yambopy.tar<br />
$ cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $CINECA_SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
$ tar -xvf hBN-convergence-kpoints.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
$ cd $CINECA_SCRATCH<br />
$ cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
$ ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Modena_2025&diff=8606Modena 20252025-05-13T08:32:29Z<p>Nicolaspallanzani: /* General instructions to run tutorials */</p>
<hr />
<div>A general description of the goal(s) of the school can be found on the [https://www.yambo-code.eu/2025/01/17/yambo-school-modena-2025/ Yambo main website]<br />
<br />
== Use CINECA computational resources ==<br />
Yambo tutorials will be run on the Leonardo-DCGP. You can find info about Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section here].<br />
In order to access computational resources provided by CINECA you need your personal username and password that were sent you by the organizers.<br />
<br />
=== Connect to the cluster using ssh ===<br />
<br />
You can access Leonardo-DCGP via <code>ssh</code> protocol in different ways.<br />
<br />
<br />
<br />
''' - Connect using username and password '''<br />
<br />
Use the following command replacing your username:<br />
$ ssh ...<br />
<br />
However, in this way you have to type your password each time you want to connect.<br />
<br />
'''FROM HERE IS A PLACEHOLDER: NICOLA WILL FILL THIS PART'''<br />
<br />
''' - Connect using ssh key '''<br />
<br />
You can setup a ssh key pair to avoid typing the password each time you want to connect to M100. To do so, go to your <code>.ssh</code> directory (usually located in the <code>home</code> directory):<br />
$ cd $HOME/.ssh<br />
<br />
If you don't have this directory, you can create it with <code>mkdir $HOME/.ssh</code>.<br />
<br />
Once you are in the <code>.ssh</code> directory, run the <code>ssh-keygen</code> command to generate a private/public key pair:<br />
$ ssh-keygen<br />
Generating public/private rsa key pair.<br />
Enter file in which to save the key: m100_id_rsa<br />
Enter passphrase (empty for no passphrase): <br />
Enter same passphrase again: <br />
Your identification has been saved in <your_.ssh_dir>/m100_id_rsa<br />
Your public key has been saved in <your_.ssh_dir>/m100_id_rsa.pub<br />
The key fingerprint is:<br />
<...><br />
The key's randomart image is:<br />
<...><br />
<br />
Now you need to copy the '''public''' key to M100. You can do that with the following command (for this step you need to type your password):<br />
$ ssh-copy-id -i <your_.ssh_dir>/m100_id_rsa.pub <username>@login.m100.cineca.it<br />
<br />
Once the public key has been copied, you can connect to M100 without having to type the password using the <code>-i</code> option:<br />
$ ssh -i <your_.ssh_dir>/m100_id_rsa username@login.m100.cineca.it<br />
<br />
To simplify even more, you can paste the following lines in a file named <code>config</code> located inside the <code>.ssh</code> directory adjusting username and path:<br />
Host m100 <br />
HostName login.m100.cineca.it<br />
User username<br />
IdentityFile <your_.ssh_dir>/m100_id_rsa<br />
<br />
With the <code>config</code> file setup you can connect simply with<br />
$ ssh m100<br />
<br />
=== General instructions to run tutorials ===<br />
<br />
Before proceeding, it is useful to know the different workspaces you have available on M100, which can be accessed using environment variables. The main ones are:<br />
* <code>$HOME</code>: it's the <code>home</code> directory associated to your username; <br />
* <code>$WORK</code>: it's the <code>work</code> directory associated to the account where the computational resources dedicated to this school are allocated;<br />
* <code>$CINECA_SCRATCH</code>: it's the <code>scratch</code> directory associated to your username.<br />
You can find more details about storage and FileSystems [https://wiki.u-gov.it/confluence/display/SCAIUS/UG2.5%3A+Data+storage+and+FileSystems here].<br />
<br />
Please don't forget to '''run all tutorials in your scratch directory''':<br />
$ echo $CINECA_SCRATCH<br />
/m100_scratch/userexternal/username<br />
$ cd $CINECA_SCRATCH<br />
<br />
Computational resources on M100 are managed by the job scheduling system [https://slurm.schedmd.com/overview.html Slurm]. Most part of Yambo tutorials during this school can be run in serial, except some that need to be executed on multiple processors. Generally, Slurm batch jobs are submitted using a script, but the tutorials here are better understood if run interactively. The two procedures that we will use to submit interactive and non interactive jobs are explained below.<br />
<br />
<br />
<br />
''' - Run a job using a batch script '''<br />
<!--<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>, whose generic structure is the following:<br />
$ more job.sh<br />
#!/bin/bash<br />
#SBATCH --account=tra25_yambo # Charge resources used by this job to specified account<br />
#SBATCH --time=00:10:00 # Set a limit on the total run time of the job allocation in hh:mm:ss<br />
#SBATCH --job-name=JOB # Specify a name for the job allocation<br />
#SBATCH --partition= dcgp_usr_prod # Request a specific partition for the resource allocation<br />
#SBATCH --gres=tmpfs:10g # List of generic consumable resources<br />
#SBATCH --qos=normal # Quality of service <br />
###SBATCH --reservation=s_tra_yambo # Reservation specific to this school (TBD)<br />
# <br />
#SBATCH --nodes=<N> # Number of nodes to be allocated for the job<br />
#SBATCH --ntasks-per-node=<n> # Number of MPI tasks invoked per node<br />
#SBATCH --ntasks-per-socket=<n/2> # Tasks invoked on each socket<br />
#SBATCH --cpus-per-task=<c> # Number of OMP threads per task<br />
<br />
module purge<br />
module load profile/candidate<br />
module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
module load yambo/5.3.0--intel-oneapi-mpi--2021.12.1--oneapi--2024.1.0<br />
export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
mpirun -np ${SLURM_NTASKS} \<br />
yambo -F <input> -J <output><br />
--><br />
<br />
This procedure is suggested for the tutorials and examples that need to be run in parallel. In these cases you need to submit the job using a batch script <code>job.sh</code>. Please note that the instructions in the batch script must be compatible with the specific Leonardo-DCGP [https://wiki.u-gov.it/confluence/display/SCAIUS/DCGP+Section#DCGPSection-SLURMpartitions resourses]. The complete list of Slurm options can be found [https://slurm.schedmd.com/sbatch.html here]. However you will find '''ready-to-use''' batch scripts in locations specified during the tutorials. <br />
<br />
To submit the job, use the <code>sbatch</code> command:<br />
$ $ sbatch job.sh<br />
Submitted batch job 15696508<br />
<br />
To check the job status, use the <code>squeue</code> command:<br />
$ squeue --me<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
15696508 dcgp_usr_ job.sh nspallan R 0:01 1 lrdn4135<br />
<br />
If you need to cancel your job, do:<br />
$ scancel <JOBID> <br />
<br />
<br />
<br />
''' - Open an interactive session '''<br />
<br />
This procedure is suggested for most of the tutorials, since the majority of these is meant to be run in serial (relatively to MPI parallelization) from the command line. Use the command below to open an interactive session of 4 hour:<br />
$ srun -A tra25_yambo -p dcgp_usr_prod -q normal -N 1 -n 1 -c 4 -t 04:00:00 --gres=tmpfs:10g --pty /bin/bash<br />
srun: job 15694182 queued and waiting for resources<br />
srun: job 15694182 has been allocated resources<br />
<br />
We ask for 4 cpus-per-task (-c) because we can exploit OpenMP parallelization with the available resources.<br />
<br />
Then, you need to manually load <code>yambo</code> as in the batch script above:<br />
$ module purge<br />
$ module load profile/candidate<br />
$ module use /leonardo/pub/userexternal/nspallan/spack-0.22.2-06/modules<br />
<br />
Finally, set the <code>OMP_NUM_THREADS</code> environment variable to 4 using the appropriate Slurm environment variable:<br />
$ export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}<br />
<br />
To close the interactive session when you have finished, log out of the compute node with the <code>exit</code> command, and then cancel the job:<br />
$ exit<br />
$ scancel <JOBID><br />
<br />
<br />
<br />
''' - Plot results with gnuplot '''<br />
<br />
During the tutorials you will often need to plot the results of the calculations. In order to do so on M100, '''open a new terminal window''' and connect to M100 enabling X11 forwarding with the <code>-X</code> option:<br />
$ ssh -X m100<br />
<br />
Please note that <code>gnuplot</code> can be used in this way only from the login nodes:<br />
username@'''login01'''$ cd <directory_with_data><br />
username@'''login01'''$ gnuplot<br />
...<br />
Terminal type is now '...'<br />
gnuplot> plot <...><br />
<br />
''' - Set up yambopy '''<br />
<br />
In order to run yambopy on m100, you must first setup the conda environment (to be done only once):<br />
$ cd<br />
$ module load anaconda/2020.11<br />
$ conda init bash<br />
$ source .bashrc<br />
<br />
After this, every time you want to use yambopy you need to load its module and environment:<br />
$ module load anaconda/2020.11<br />
$ conda activate /m100_work/tra23_Yambo/softwares/YAMBO/env_yambopy<br />
<br />
== Tutorials ==<br />
<br />
Quick recap.<br />
Before every tutorial, if you run on m100, do the following steps<br />
<br />
ssh m100<br />
cd $CINECA_SCRATCH<br />
mkdir YAMBO_TUTORIALS '''(Only if you didn't before)'''<br />
cd YAMBO_TUTORIALS<br />
<br />
At this point you can download the needed files for the tutorial.<br />
After that you can open the interactive session and login into the node<br />
<br />
salloc -A tra23_Yambo -p m100_sys_test -q qos_test --reservation=s_tra_yambo --nodes=1 --ntasks-per-node=1 --cpus-per-task=4 -t 04:00:00<br />
ssh '''PUT HERE THE ASSIGNED NODE NAME AFTER salloc COMMAND'''<br />
module purge<br />
module load hpc-sdk/2022--binary spectrum_mpi/10.4.0--binary<br />
export PATH=/m100_work/tra23_Yambo/softwares/YAMBO/5.2-cpu/bin:$PATH<br />
cd $CINECA_SCRATCH<br />
cd YAMBO_TUTORIALS <br />
<br />
=== DAY 1 - Monday, 19 May === <br />
<br />
'''16:15 - 18:30 From the DFT ground state to the complete setup of a Many Body calculation using Yambo'''<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ ls<br />
hBN-2D.tar.gz hBN.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
$ ls<br />
'''hBN-2D''' '''hBN''' hBN-2D.tar.gz hBN.tar.gz<br />
<br />
Now that you have all the files, you may open the interactive job session with <code>salloc</code> as explained above and proceed with the tutorials.<br />
<br />
* [[First steps: walk through from DFT(standalone)|First steps: Initialization and more ]]<br />
* [[Next steps: RPA calculations (standalone)|Next steps: RPA calculations ]]<br />
<br />
At this point, you may learn about the python pre-postprocessing capabilities offered by yambopy, our python interface to yambo and QE. First of all, let's create a dedicated directory, download and extract the related files.<br />
<br />
$ cd $CINECA_SCRATCH<br />
$ mkdir YAMBOPY_TUTORIALS<br />
$ cd YAMBOPY_TUTORIALS<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/databases_yambopy.tar<br />
$ tar -xvf databases_yambopy.tar<br />
$ cd databases_yambopy<br />
<br />
Then, follow '''the first three sections''' of this link, which are related to initialization and linear response.<br />
* [[Yambopy tutorial: Yambo databases|Reading databases with yambopy]]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
'''14:00 - 16:30 A tour through GW simulation in a complex material (from the blackboard to numerical computation: convergence, algorithms, parallel usage)'''<br />
<br />
To get all the tutorial files needed for the following tutorials, follow these steps:<br />
<br />
wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz<br />
wget https://media.yambo-code.eu/educational/tutorials/files/MoS2_2Dquasiparticle_tutorial.tar.gz<br />
tar -xvf hBN.tar.gz<br />
tar -xvf MoS2_2Dquasiparticle_tutorial.tar.gz<br />
cd hBN<br />
<br />
Now you can start the first tutorial:<br />
<br />
* [[GW tutorial Rome 2023 | GW computations on practice: how to obtain the quasi-particle band structure of a bulk material ]]<br />
<br />
If you have gone through the first tutorial, pass now to the second one:<br />
<br />
cd $CINECA_SCRATCH<br />
cd YAMBO_TUTORIALS<br />
cd MoS2_HPC_tutorial<br />
<br />
* [[Quasi-particles of a 2D system | Quasi-particles of a 2D system ]]<br />
<br />
To conclude, you can learn an other method to plot the band structure in Yambo<br />
<br />
* [[Yambopy tutorial: band structures| Yambopy tutorial: band structures]]<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
'''14:00 - 16:30 Bethe-Salpeter equation (BSE)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
To get the tutorial files needed for the following tutorials, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN.tar.gz # NOTE: YOU SHOULD ALREADY HAVE THIS FROM DAY 1<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-convergence-kpoints.tar.gz <br />
$ tar -xvf hBN-convergence-kpoints.tar.gz<br />
$ tar -xvf hBN.tar.gz<br />
<br />
Now, you may open the interactive job session with <code>salloc</code> and proceed with the following tutorials.<br />
<br />
* [[Calculating optical spectra including excitonic effects: a step-by-step guide|Perform a BSE calculation from beginning to end ]]<br />
* [[How to analyse excitons - ICTP 2022 school|Analyse your results (exciton wavefunctions in real and reciprocal space, etc.) ]]<br />
* [[BSE solvers overview|Solve the BSE eigenvalue problem with different numerical methods]]<br />
* [[How to choose the input parameters|Choose the input parameters for a meaningful converged calculation]]<br />
Now, go into the yambopy tutorial directory to learn about python analysis tools for the BSE:<br />
$ cd $CINECA_SCRATCH<br />
$ cd YAMBOPY_TUTORIALS/databases_yambopy<br />
<br />
* [[Yambopy_tutorial:_Yambo_databases#Exciton_intro_1:_read_and_sort_data|Visualization of excitonic properties with yambopy]]<br />
<br />
<br />
<br />
'''17:00 - 18:30 Bethe-Salpeter equation in real time (TD-HSEX)''' Fulvio Paleari (CNR-Nano, Italy), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
The files needed for the following tutorials can be downloaded following these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Introduction_to_Real_Time_propagation_in_Yambo#Time_Dependent_Equation_for_the_Reduced_One--Body_Density--Matrix|Read the introductive section to real-time propagation for the one-body density matrix]] (the part about time-dependent Schrödinger equation will be covered on DAY 4 and you can skip it for now)<br />
* [[Prerequisites for Real Time propagation with Yambo|Perform the setup for a real-time calculation]]<br />
* [[Linear response from real time simulations (density matrix only)|Calculate the linear response in real time]]<br />
* [[Real time Bethe-Salpeter Equation (density matrix only)|Calculate the BSE in real time]]<br />
<br />
=== DAY 4 - Thursday, May 22 ===<br />
<br />
'''14:00 - 16:30 Real-time approach with the time dependent berry phase''' Myrta Gruning (Queen's University Belfast), Davide Sangalli (CNR-ISM, Italy)<br />
<br />
<br />
For the tutorials we will use first the <code>hBN-2D-RT</code> folder (k-sampling 10x10x1) and then the <code>hBN-2D</code> folder (k-sampling 6x6x1)<br />
You may already have them in the <code>YAMBO_TUTORIALS</code> folder<br />
$ ls<br />
'''hBN-2D''' '''hBN-2D-RT''' hBN-2D.tar.gz hBN-2D-RT.tar.gz<br />
<br />
If you need to downoload again the tutorial files, follow these steps:<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D.tar.gz<br />
$ wget https://media.yambo-code.eu/educational/tutorials/files/hBN-2D-RT.tar.gz<br />
$ tar -xvf hBN-2D.tar.gz<br />
$ tar -xvf hBN-2D-RT.tar.gz<br />
<br />
<br />
* [[Dielectric function from Bloch-states dynamics]]<br />
* [[Second-harmonic generation of 2D-hBN]]<br />
<br />
* [[Real time approach to non-linear response]] (additional tutorial)<br />
* [[Correlation effects in the non-linear response]] (additional tutorial)<br />
<br />
=== DAY 5 - Friday, 23 May ===<br />
<br />
== Lectures ==<br />
<br />
<br />
=== DAY 1 - Monday, 19 May ===<br />
<br />
* D. Varsano, [Description and goal of the school].<br />
* C. Franchini, [First principles and data-driven correlated materials]<br />
* F. Mohamed, [A tour on Density Functional Theory]<br />
* E. Cannuccia, [Electronic screening and linear response theory]<br />
<br />
=== DAY 2 - Tuesday, 20 May ===<br />
<br />
* A. Marini, Introduction to Many-Body Perturbation Theory<br />
* C. Cardoso, Quasiparticles and the GW Approximation<br />
* A. Guandalini,G. Sesti, GW in practice: algorithms, approximations and W-averaged GW in metals<br />
* M. Govoni, GW without empty states and investigation of neutral excitations by embedding full configuration interaction in DFT+GW<br />
<br />
=== DAY 3 - Wednesday, 21 May ===<br />
<br />
* M. Palummo, Optical absorption and excitons via the Bethe-Salpeter Equation<br />
* D. Sangalli, Real-time simulations<br />
* F. Paleari, Introduction to YamboPy (automation and post-processing)<br />
<br />
=== DAY 4 - Thursday, 22 May ===<br />
<br />
* E. Luppi, An introduction to Non-linear spectroscopy<br />
* M. Grüning, Non-linear spectroscopy in Yambo<br />
* F. Affinito, Frontiers in High-Performance Computing</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Install_Yambo_on_Ubuntu/LinuxMint_with_NVfortran_compiler&diff=8441Install Yambo on Ubuntu/LinuxMint with NVfortran compiler2025-03-11T09:50:53Z<p>Nicolaspallanzani: </p>
<hr />
<div>The NVIDIA compiler are freely available on Linux machines.<br />
You can download Fortran,C, C++ compiler and debugger from:<br />
[https://developer.nvidia.com/hpc-sdk-downloads NVIDIA HPC Software Development Kit (SDK) ] <br><br />
On Ubuntu, it can be easely installed via the following procedure<br />
sudo apt-get update -y && sudo apt-get upgrade -y<br />
sudo apt-get install -y build-essential automake autoconf libtool zlib1g-dev curl gpg wget git tar cmake<br />
curl https://developer.download.nvidia.com/hpc-sdk/ubuntu/DEB-GPG-KEY-NVIDIA-HPC-SDK | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-hpcsdk-archive-keyring.gpg<br />
echo 'deb [signed-by=/usr/share/keyrings/nvidia-hpcsdk-archive-keyring.gpg] https://developer.download.nvidia.com/hpc-sdk/ubuntu/amd64 /' | sudo tee /etc/apt/sources.list.d/nvhpc.list<br />
sudo apt-get update -y && sudo apt-get install -y nvhpc-25-1<br />
<br />
'''Setup NVIDIA compilers '''<br />
<br />
Once you downloaded and installed the NVIDIA SDK it is suggested avoiding manually setting environment variables for compilers and MPI wrappers. The safest approach is to use the module files provided by Nvidia, located at: `/opt/nvidia/hpc_sdk/modulefiles`<br />
<br />
Before using module files, you need to install the module management tool:<br />
<br />
sudo apt-get install environment-modules<br />
echo "source /etc/profile.d/modules.sh" >> ~/.bashrc<br />
echo "module use /opt/nvidia/hpc_sdk/modulefiles" >> ~/.bashrc<br />
source ~/.bashrc<br />
<br />
The commands above only need to be used the first time. Now, you can load the Nvidia SDK module, which will correctly set up all environment variables for both compilers and MPI:<br />
<br />
module load nvhpc/25.1<br />
<br />
'''Configure Yambo with NVfortran and openMPI '''<br />
<br />
Then you can configure Yambo with the command:<br />
<br />
./configure MPIFC=mpif90 MPICC=mpicc FC=nvfortran F77=nvfortran CPP="cpp -E" FPP="nvfortran -Mpreprocess -E" F90SUFFIX=".f90" \<br />
--enable-memory-profile --enable-open-mp --enable-par-linalg --enable-hdf5-par-io --enable-slepc-linalg <br />
<br />
If you have an installed CUDA GPU on your machine you can compile Yambo to use it, by adding the flag<br />
<span style="color:#0000FF">''--enable-cuda-fortran</span> <br />
and then specify your GPU architecture and the CUDA runtime version, look at configure help for more info.<br />
<br />
'''Check that your Nvidia graphic card is properly installed'''<br />
<br />
To be sure that the code will run fine on your GPU card, you need the proper driver installed on your machine. If you have the nvidia drivers, just run<br />
$nvidia-smi<br />
Mon Sep 9 16:20:02 2024 <br />
+-----------------------------------------------------------------------------------------+<br />
| NVIDIA-SMI 560.35.03 Driver Version: 560.35.03 CUDA Version: 12.6 |<br />
|-----------------------------------------+------------------------+----------------------+<br />
| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |<br />
| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |<br />
| | | MIG M. |<br />
|=========================================+========================+======================|<br />
| 0 NVIDIA GeForce GTX 1650 Off | 00000000:01:00.0 On | N/A |<br />
| 20% 39C P8 8W / 75W | 280MiB / 4096MiB | 0% Default |<br />
| | | N/A |<br />
+-----------------------------------------+------------------------+----------------------+<br />
''CUDA Version: V.S'' should be lower or equal to what you set in your ''cuda-runtime'' in the configure. In this case we are running with driver 560, which supports cuda version 12.6 or newer via the CUDA Forward Compatibility Package (see [https://docs.nvidia.com/deploy/cuda-compatibility/ https://docs.nvidia.com/deploy/cuda-compatibility/]).<br />
<br />
More info on Yambo on NVIDIA graphic cards can be found here: [https://www.nvidia.com/en-us/on-demand/session/gtcspring21-e32448/ Materials Design Toward the Exascale: Porting Electronic Structure Community Codes to GPUs]</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Install_Yambo_on_Ubuntu/LinuxMint_with_NVfortran_compiler&diff=8440Install Yambo on Ubuntu/LinuxMint with NVfortran compiler2025-03-11T09:48:38Z<p>Nicolaspallanzani: </p>
<hr />
<div>The NVIDIA compiler are freely available on Linux machines.<br />
You can download Fortran,C, C++ compiler and debugger from:<br />
[https://developer.nvidia.com/hpc-sdk-downloads NVIDIA HPC Software Development Kit (SDK) ] <br><br />
On Ubuntu, it can be easely installed via the following procedure<br />
sudo apt-get update -y<br />
sudo apt-get upgrade -y<br />
sudo apt-get install -y build-essential automake autoconf libtool zlib1g-dev curl gpg wget git tar cmake<br />
curl https://developer.download.nvidia.com/hpc-sdk/ubuntu/DEB-GPG-KEY-NVIDIA-HPC-SDK | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-hpcsdk-archive-keyring.gpg<br />
echo 'deb [signed-by=/usr/share/keyrings/nvidia-hpcsdk-archive-keyring.gpg] https://developer.download.nvidia.com/hpc-sdk/ubuntu/amd64 /' | sudo tee /etc/apt/sources.list.d/nvhpc.list<br />
sudo apt-get update -y<br />
sudo apt-get install -y nvhpc-25-1 <br />
<br />
'''Setup NVIDIA compilers '''<br />
<br />
Once you downloaded and installed the NVIDIA SDK it is suggested avoiding manually setting environment variables for compilers and MPI wrappers. The safest approach is to use the module files provided by Nvidia, located at: `/opt/nvidia/hpc_sdk/modulefiles`<br />
<br />
Before using module files, you need to install the module management tool:<br />
<br />
sudo apt-get install environment-modules<br />
echo "source /etc/profile.d/modules.sh" >> ~/.bashrc<br />
echo "module use /opt/nvidia/hpc_sdk/modulefiles" >> ~/.bashrc<br />
source ~/.bashrc<br />
<br />
The commands above only need to be used the first time. Now, you can load the Nvidia SDK module, which will correctly set up all environment variables for both compilers and MPI:<br />
<br />
module load nvhpc/25.1<br />
<br />
'''Configure Yambo with NVfortran and openMPI '''<br />
<br />
Then you can configure Yambo with the command:<br />
<br />
./configure MPIFC=mpif90 MPICC=mpicc FC=nvfortran F77=nvfortran CPP="cpp -E" FPP="nvfortran -Mpreprocess -E" F90SUFFIX=".f90" \<br />
--enable-memory-profile --enable-open-mp --enable-par-linalg --enable-hdf5-par-io --enable-slepc-linalg <br />
<br />
If you have an installed CUDA GPU on your machine you can compile Yambo to use it, by adding the flag<br />
<span style="color:#0000FF">''--enable-cuda-fortran</span> <br />
and then specify your GPU architecture and the CUDA runtime version, look at configure help for more info.<br />
<br />
'''Check that your Nvidia graphic card is properly installed'''<br />
<br />
To be sure that the code will run fine on your GPU card, you need the proper driver installed on your machine. If you have the nvidia drivers, just run<br />
$nvidia-smi<br />
Mon Sep 9 16:20:02 2024 <br />
+-----------------------------------------------------------------------------------------+<br />
| NVIDIA-SMI 560.35.03 Driver Version: 560.35.03 CUDA Version: 12.6 |<br />
|-----------------------------------------+------------------------+----------------------+<br />
| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |<br />
| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |<br />
| | | MIG M. |<br />
|=========================================+========================+======================|<br />
| 0 NVIDIA GeForce GTX 1650 Off | 00000000:01:00.0 On | N/A |<br />
| 20% 39C P8 8W / 75W | 280MiB / 4096MiB | 0% Default |<br />
| | | N/A |<br />
+-----------------------------------------+------------------------+----------------------+<br />
''CUDA Version: V.S'' should be lower or equal to what you set in your ''cuda-runtime'' in the configure. In this case we are running with driver 560, which supports cuda version 12.6 or newer via the CUDA Forward Compatibility Package (see [https://docs.nvidia.com/deploy/cuda-compatibility/ https://docs.nvidia.com/deploy/cuda-compatibility/]).<br />
<br />
More info on Yambo on NVIDIA graphic cards can be found here: [https://www.nvidia.com/en-us/on-demand/session/gtcspring21-e32448/ Materials Design Toward the Exascale: Porting Electronic Structure Community Codes to GPUs]</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Install_Yambo_on_Ubuntu/LinuxMint_with_NVfortran_compiler&diff=8417Install Yambo on Ubuntu/LinuxMint with NVfortran compiler2025-03-10T12:21:30Z<p>Nicolaspallanzani: </p>
<hr />
<div>The NVIDIA compiler are freely available on Linux machines.<br />
You can download Fortran,C, C++ compiler and debugger from:<br />
[https://developer.nvidia.com/hpc-sdk-downloads NVIDIA HPC Software Development Kit (SDK) ] <br><br />
On Ubuntu, it can be easely installed via the following procedure<br />
curl https://developer.download.nvidia.com/hpc-sdk/ubuntu/DEB-GPG-KEY-NVIDIA-HPC-SDK | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-hpcsdk-archive-keyring.gpg<br />
echo 'deb [signed-by=/usr/share/keyrings/nvidia-hpcsdk-archive-keyring.gpg] https://developer.download.nvidia.com/hpc-sdk/ubuntu/amd64 /' | sudo tee /etc/apt/sources.list.d/nvhpc.list<br />
sudo apt-get update -y<br />
sudo apt-get install -y nvhpc-25-1 <br />
<br />
'''Setup NVIDIA compilers '''<br />
<br />
Once you downloaded and installed the NVIDIA SDK it is suggested avoiding manually setting environment variables for compilers and MPI wrappers. The safest approach is to use the module files provided by Nvidia, located at: `/opt/nvidia/hpc_sdk/modulefiles`<br />
<br />
Before using module files, you need to install the module management tool:<br />
<br />
sudo apt install environment-modules<br />
echo "source /etc/profile.d/modules.sh" >> ~/.bashrc<br />
echo "module use /opt/nvidia/hpc_sdk/modulefiles" >> ~/.bashrc<br />
source ~/.bashrc<br />
<br />
The commands above only need to be used the first time. Now, you can load the Nvidia SDK module, which will correctly set up all environment variables for both compilers and MPI:<br />
<br />
module load nvhpc/25.1<br />
<br />
'''Configure Yambo with NVfortran and openMPI '''<br />
<br />
Then you can configure Yambo with the command:<br />
<br />
./configure MPIFC=mpif90 MPICC=mpicc FC=nvfortran F77=nvfortran CPP="cpp -E" FPP="nvfortran -Mpreprocess -E" F90SUFFIX=".f90" \<br />
--enable-memory-profile --enable-open-mp --enable-par-linalg --enable-hdf5-par-io --enable-slepc-linalg <br />
<br />
If you have an installed CUDA GPU on your machine you can compile Yambo to use it, by adding the flag<br />
<span style="color:#0000FF">''--enable-cuda-fortran</span> <br />
and then specify your GPU architecture and the CUDA runtime version, look at configure help for more info.<br />
<br />
'''Check that your Nvidia graphic card is properly installed'''<br />
<br />
To be sure that the code will run fine on your GPU card, you need the proper driver installed on your machine. If you have the nvidia drivers, just run<br />
$nvidia-smi<br />
Mon Sep 9 16:20:02 2024 <br />
+-----------------------------------------------------------------------------------------+<br />
| NVIDIA-SMI 560.35.03 Driver Version: 560.35.03 CUDA Version: 12.6 |<br />
|-----------------------------------------+------------------------+----------------------+<br />
| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |<br />
| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |<br />
| | | MIG M. |<br />
|=========================================+========================+======================|<br />
| 0 NVIDIA GeForce GTX 1650 Off | 00000000:01:00.0 On | N/A |<br />
| 20% 39C P8 8W / 75W | 280MiB / 4096MiB | 0% Default |<br />
| | | N/A |<br />
+-----------------------------------------+------------------------+----------------------+<br />
''CUDA Version: V.S'' should be lower or equal to what you set in your ''cuda-runtime'' in the configure. In this case we are running with driver 560, which supports cuda version 12.6 or newer via the CUDA Forward Compatibility Package (see [https://docs.nvidia.com/deploy/cuda-compatibility/ https://docs.nvidia.com/deploy/cuda-compatibility/]).<br />
<br />
More info on Yambo on NVIDIA graphic cards can be found here: [https://www.nvidia.com/en-us/on-demand/session/gtcspring21-e32448/ Materials Design Toward the Exascale: Porting Electronic Structure Community Codes to GPUs]</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Install_Yambo_on_Ubuntu/LinuxMint_with_NVfortran_compiler&diff=8416Install Yambo on Ubuntu/LinuxMint with NVfortran compiler2025-03-10T11:44:22Z<p>Nicolaspallanzani: </p>
<hr />
<div>The NVIDIA compiler are freely available on Linux machines.<br />
You can download Fortran,C, C++ compiler and debugger from:<br />
[https://developer.nvidia.com/hpc-sdk-downloads NVIDIA HPC Software Development Kit (SDK) ] <br><br />
On Ubuntu, it can be easely installed via the following procedure<br />
curl https://developer.download.nvidia.com/hpc-sdk/ubuntu/DEB-GPG-KEY-NVIDIA-HPC-SDK | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-hpcsdk-archive-keyring.gpg<br />
echo 'deb [signed-by=/usr/share/keyrings/nvidia-hpcsdk-archive-keyring.gpg] https://developer.download.nvidia.com/hpc-sdk/ubuntu/amd64 /' | sudo tee /etc/apt/sources.list.d/nvhpc.list<br />
sudo apt-get update -y<br />
sudo apt-get install -y nvhpc-25-1 <br />
<br />
'''Setup NVIDIA compilers '''<br />
<br />
Once you downloaded and installed the NVIDIA SDK it is suggested avoiding manually setting environment variables for compilers and MPI wrappers. The safest approach is to use the module files provided by Nvidia, located at: `/opt/nvidia/hpc_sdk/modulefiles`<br />
<br />
Before using module files, you need to install the module management tool:<br />
<br />
sudo apt install environment-modules<br />
echo "source /etc/profile.d/modules.sh" >> ~/.bashrc<br />
echo "module use /opt/nvidia/hpc_sdk/modulefiles" >> ~/.bashrc<br />
source ~/.bashrc<br />
<br />
The commands above only need to be used the first time. Now, you can load the Nvidia SDK module, which will correctly set up all environment variables for both compilers and MPI:<br />
<br />
module load nvhpc/25.1<br />
<br />
'''Configure Yambo with NVfortran and openMPI '''<br />
<br />
Then you can configure Yambo with the command:<br />
<br />
./configure MPIFC=mpif90 MPICC=mpicc FC=nvfortran F77=nvfortran CPP="cpp -E" FPP="nvfortran -Mpreprocess -E" F90SUFFIX=".f90" \<br />
--enable-memory-profile --enable-open-mp --enable-par-linalg --enable-hdf5-par-io --enable-slepc-linalg <br />
<br />
If you have an installed CUDA GPU on your machine you can compile Yambo to use it, by adding the flag<br />
<span style="color:#0000FF">''--enable-cuda-fortran</span> <br />
and then specify your GPU architecture and the CUDA runtime version, look at configure help for more info.<br />
<br />
'''Check that your Nvidia graphic card is properly installed'''<br />
<br />
To be sure that the code will run fine on your GPU card, you need the proper driver installed on your machine. If you have the nvidia drivers, just run<br />
$nvidia-smi<br />
Mon Sep 9 16:20:02 2024 <br />
+-----------------------------------------------------------------------------------------+<br />
| NVIDIA-SMI 560.35.03 Driver Version: 560.35.03 CUDA Version: 12.6 |<br />
|-----------------------------------------+------------------------+----------------------+<br />
| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |<br />
| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |<br />
| | | MIG M. |<br />
|=========================================+========================+======================|<br />
| 0 NVIDIA GeForce GTX 1650 Off | 00000000:01:00.0 On | N/A |<br />
| 20% 39C P8 8W / 75W | 280MiB / 4096MiB | 0% Default |<br />
| | | N/A |<br />
+-----------------------------------------+------------------------+----------------------+<br />
''CUDA Version: V.S'' should be lower or equal to what you set in your ''cuda-runtime'' in the configure. In this case we are running with driver 560, which supports cuda version 12.6 or greater via the CUDA Forward Compatibility Package (see [https://docs.nvidia.com/deploy/cuda-compatibility/ https://docs.nvidia.com/deploy/cuda-compatibility/]).<br />
<br />
More info on Yambo on NVIDIA graphic cards can be found here: [https://www.nvidia.com/en-us/on-demand/session/gtcspring21-e32448/ Materials Design Toward the Exascale: Porting Electronic Structure Community Codes to GPUs]</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Install_Yambo_on_MacOS_(ARM)&diff=8321Install Yambo on MacOS (ARM)2024-12-12T11:04:47Z<p>Nicolaspallanzani: </p>
<hr />
<div>In order to install YAMBO on a Mac computer with ARM architecture, it is first necessary to set up a development environment on the target computer. At a minimum, this requires Fortran and C/C++ compilers suitable for compiling code on ARM architectures, such as the GNU Compiler Collection (GCC). HomeBrew, a package manager for macOS (or Linux), can be used to install the compilers and some of the libraries needed. For libraries not available in the HomeBrew repository or those that did not meet the necessary requirements, the installation can be handled by the automated procedure developed within YAMBO itself.<br />
<br />
==== Preparing of the development environment ====<br />
<br />
The software HomeBrew needs to be installed first:<br />
<br />
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"<br />
<br />
And to install the compiler and the libraries is possible to use these commands:<br />
<br />
brew install gcc<br />
brew install open-mpi<br />
brew install openblas fftw libxc<br />
brew install hdf5 netcdf netcdf-fortran<br />
<br />
In a first test machine (MacBook Air M1, macOS Sonoma v14.6.1) this is a partial list of the installed packages and versions:<br />
<br />
% brew list --versions<br />
[...]<br />
cmake 3.26.4<br />
fftw 3.3.10_1<br />
gcc 14.2.0_1<br />
hdf5 1.14.4.3<br />
libxc 6.2.0<br />
netcdf 4.9.2_2<br />
netcdf-fortran 4.6.1_1<br />
open-mpi 5.0.5<br />
openblas 0.3.28<br />
scalapack 2.2.0_1<br />
gcc-aarch64-embedded 12.2.rel1<br />
<br />
==== Installing YAMBO ====<br />
<br />
The features required to compile YAMBO on ARM architectures will be publicly released in the next version, 5.3.<br />
Nevertheless, you can already experiment with the installation using the tech-master development branch of the official GitHub code repository:<br />
<br />
git clone https://github.com/yambo-code/yambo.git<br />
cd yambo<br />
git checkout tech-master<br />
<br />
Finally YAMBO can be successfully compiled with the following configuration:<br />
<br />
export OMPI_CC=/opt/homebrew/bin/gcc-14<br />
OPT=/opt/homebrew/opt<br />
./configure \<br />
CC=gcc-14 \<br />
CPP="gcc-14 -E -P" \<br />
MPICC=mpicc \<br />
FC=gfortran-14 \<br />
F77=gfortran-14 \<br />
FPP="gfortran-14 -E -P" \<br />
MPIFC=mpifort \<br />
--enable-mpi \<br />
--enable-open-mp \<br />
--disable-hdf5-par-io \<br />
--enable-time-profile \<br />
--enable-memory-profile \<br />
--enable-msgs-comps \<br />
--with-blas-libs="-L$OPT/openblas/lib -lopenblas" \<br />
--with-lapack-libs="-L$OPT/openblas/lib -lopenblas" \<br />
--with-libxc-path=$OPT/libxc \<br />
--with-fft-path=$OPT/fftw \<br />
--with-hdf5-path=$OPT/hdf5 \<br />
--with-netcdf-path=$OPT/netcdf \<br />
--with-netcdff-path=$OPT/netcdf-fortran \<br />
--enable-par-linalg \<br />
--with-scalapack-libs="-L$OPT/scalapack/lib -lscalapack" \<br />
--with-blacs-libs="-L$OPT/scalapack/lib -lscalapack" \<br />
--enable-slepc-linalg \<br />
--with-extlibs-path=$HOME/opt/ext-libs<br />
make -j4 all<br />
<br />
gcc-14 and gfortran-14 can be substituted with the compiler version used, see below how to check the version of the packages installed with HomeBrew.<br />
<br />
==== Troubleshooting: ====<br />
<br />
An issue was identified with the mpicc wrapper. It was expected to use the gcc-14 C compiler internally; however, it was found to be using the Apple Clang compiler instead:<br />
<br />
mpicc -show<br />
clang -I/opt/homebrew/Cellar/open-mpi/5.0.5/include -L/opt/homebrew/Cellar/open-mpi/5.0.5/lib -lmpi<br />
<br />
The issue was solved using the OMPI_CC environment variable to specify the C compiler:<br />
<br />
export OMPI_CC=/opt/homebrew/bin/gcc-14 <br />
mpicc --show<br />
/opt/homebrew/bin/gcc-14 -I/opt/homebrew/Cellar/open-mpi/5.0.5/include -L/opt/homebrew/Cellar/open-mpi/5.0.5/lib -lmpi</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Install_Yambo_on_MacOS_(ARM)&diff=8320Install Yambo on MacOS (ARM)2024-12-12T11:03:46Z<p>Nicolaspallanzani: Created page with "In order to install YAMBO on Mac with ARM architecture, it is first necessary to set up a development environment on the target computer. At a minimum, this requires Fortran and C/C++ compilers suitable for compiling code on ARM architectures, such as the GNU Compiler Collection (GCC). HomeBrew, a package manager for macOS (or Linux), can be used to install the compilers and some of the libraries needed. For libraries not available in the HomeBrew repository or those tha..."</p>
<hr />
<div>In order to install YAMBO on Mac with ARM architecture, it is first necessary to set up a development environment on the target computer. At a minimum, this requires Fortran and C/C++ compilers suitable for compiling code on ARM architectures, such as the GNU Compiler Collection (GCC). HomeBrew, a package manager for macOS (or Linux), can be used to install the compilers and some of the libraries needed. For libraries not available in the HomeBrew repository or those that did not meet the necessary requirements, the installation can be handled by the automated procedure developed within YAMBO itself.<br />
<br />
==== Preparing of the development environment ====<br />
<br />
The software HomeBrew needs to be installed first:<br />
<br />
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"<br />
<br />
And to install the compiler and the libraries is possible to use these commands:<br />
<br />
brew install gcc<br />
brew install open-mpi<br />
brew install openblas fftw libxc<br />
brew install hdf5 netcdf netcdf-fortran<br />
<br />
In a first test machine (MacBook Air M1, macOS Sonoma v14.6.1) this is a partial list of the installed packages and versions:<br />
<br />
% brew list --versions<br />
[...]<br />
cmake 3.26.4<br />
fftw 3.3.10_1<br />
gcc 14.2.0_1<br />
hdf5 1.14.4.3<br />
libxc 6.2.0<br />
netcdf 4.9.2_2<br />
netcdf-fortran 4.6.1_1<br />
open-mpi 5.0.5<br />
openblas 0.3.28<br />
scalapack 2.2.0_1<br />
gcc-aarch64-embedded 12.2.rel1<br />
<br />
==== Installing YAMBO ====<br />
<br />
The features required to compile YAMBO on ARM architectures will be publicly released in the next version, 5.3.<br />
Nevertheless, you can already experiment with the installation using the tech-master development branch of the official GitHub code repository:<br />
<br />
git clone https://github.com/yambo-code/yambo.git<br />
cd yambo<br />
git checkout tech-master<br />
<br />
Finally YAMBO can be successfully compiled with the following configuration:<br />
<br />
export OMPI_CC=/opt/homebrew/bin/gcc-14<br />
OPT=/opt/homebrew/opt<br />
./configure \<br />
CC=gcc-14 \<br />
CPP="gcc-14 -E -P" \<br />
MPICC=mpicc \<br />
FC=gfortran-14 \<br />
F77=gfortran-14 \<br />
FPP="gfortran-14 -E -P" \<br />
MPIFC=mpifort \<br />
--enable-mpi \<br />
--enable-open-mp \<br />
--disable-hdf5-par-io \<br />
--enable-time-profile \<br />
--enable-memory-profile \<br />
--enable-msgs-comps \<br />
--with-blas-libs="-L$OPT/openblas/lib -lopenblas" \<br />
--with-lapack-libs="-L$OPT/openblas/lib -lopenblas" \<br />
--with-libxc-path=$OPT/libxc \<br />
--with-fft-path=$OPT/fftw \<br />
--with-hdf5-path=$OPT/hdf5 \<br />
--with-netcdf-path=$OPT/netcdf \<br />
--with-netcdff-path=$OPT/netcdf-fortran \<br />
--enable-par-linalg \<br />
--with-scalapack-libs="-L$OPT/scalapack/lib -lscalapack" \<br />
--with-blacs-libs="-L$OPT/scalapack/lib -lscalapack" \<br />
--enable-slepc-linalg \<br />
--with-extlibs-path=$HOME/opt/ext-libs<br />
make -j4 all<br />
<br />
gcc-14 and gfortran-14 can be substituted with the compiler version used, see below how to check the version of the packages installed with HomeBrew.<br />
<br />
==== Troubleshooting: ====<br />
<br />
An issue was identified with the mpicc wrapper. It was expected to use the gcc-14 C compiler internally; however, it was found to be using the Apple Clang compiler instead:<br />
<br />
mpicc -show<br />
clang -I/opt/homebrew/Cellar/open-mpi/5.0.5/include -L/opt/homebrew/Cellar/open-mpi/5.0.5/lib -lmpi<br />
<br />
The issue was solved using the OMPI_CC environment variable to specify the C compiler:<br />
<br />
export OMPI_CC=/opt/homebrew/bin/gcc-14 <br />
mpicc --show<br />
/opt/homebrew/bin/gcc-14 -I/opt/homebrew/Cellar/open-mpi/5.0.5/include -L/opt/homebrew/Cellar/open-mpi/5.0.5/lib -lmpi</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Installation&diff=8319Installation2024-12-12T10:14:01Z<p>Nicolaspallanzani: </p>
<hr />
<div>=== Download ===<br />
<br />
The Yambo source code can be downloaded from several sources. Refer to the [[Download|dedicated page]] for further informations.<br />
<br />
=== Quick Configuration (with long compilation) ===<br />
<br />
Yambo can make good use of external libraries like FFTW, LAPACK, netCDF, HDF5, IOTK, LIBXC and so on. It is worth identifying if they are already installed on your system, especially for HPC machines.<br />
<br />
If you are lucky, the configure script will successfully find the best compiler options. Moving in the source directory you can configure quickly Yambo and start the compilation simply with these two commands:<br />
$ ./configure<br />
$ make core<br />
<br />
This leads to a very long compilation because Yambo will download and compile all the required libraries. Executables are found in the <tt>bin</tt> folder. To check that it works:<br />
<br />
<br />
The simplest install of yambo is the one using internal libraries and compiled with gfortran. This is useful to test the code on your local machine, or in order to easily follow the [[Tutorials|yambo tutorials]].<br />
$ ./bin/yambo<br />
<br />
Cannot access CORE database (SAVE/*db1 and/or SAVE/*wf)<br />
<br />
This is the expected error message since we didn't provide the input database needed by Yambo.<br />
<br />
=== Custom Configuration ===<br />
<br />
In general, however, some fine-tuning will be necessary to link the requested libraries. <br />
It is also possible to customize the configurazion using configure options that allow you to enable or disable some features. In order to have a complete list of all those options use the command<br />
<br />
$./configure --help<br />
<br />
After configure, you can also edit the <code>config/setup</code> file. You can run the following configure script (named for example <code>yambo_install.sh</code>) which should work for '''yambo 5.0''' on '''Linux machines''':<br />
YAMBO_EXT_LIBS="/user/defined/path/for/internal/libs"<br />
./configure FC=gfortran \<br />
--with-extlibs-path=$YAMBO_EXT_LIBS \<br />
--enable-keep-extlibs \<br />
--enable-time-profile \<br />
--enable-msgs-comps \<br />
--enable-keep-src \<br />
--enable-memory-profile \<br />
--enable-int-linalg \<br />
--enable-par-linalg \<br />
--enable-netcdf-output \<br />
--enable-slepc-linalg<br />
<br />
==== Specific Configuration options ====<br />
<br />
Here some info about the different configuration options:<br />
* [[configure-suggested|Details on configure options for yambo]]<br />
<br />
Here is a list of specific configuration options.<br />
* [[configure-5.0|Configure options for yambo 5.0]] <br />
* [[configure-4.4.0|Configure options for Yambo 4.4]]<br />
* [[configure options for Yambo v4|Configure options for Yambo v4 and v3]]<br />
<br />
=== Further informations ===<br />
<br />
* [[Install Yambo on Ubuntu/LinuxMint]] (2021, Yambo 5.1)<br />
* [[Install Yambo on Ubuntu/LinuxMint with Intel compiler]] (2021, Yambo 5.1)<br />
* [[Install Yambo on Ubuntu/LinuxMint with NVfortran compiler]] (2024, Yambo 5.2)<br />
* [[Install Yambo on MacOS (ARM)]] (2024, Yambo 5.3)<br />
* [[Install Yambo in IRENE machine (TGCC Joliot Curie)]]<br />
* [[Compile the libraries in Yambo independently]]<br />
* [[Install Yambo with external HDF5 and NetCDF libraries]]<br />
* [[Static Yambo]]<br />
* [[Machine specific configure scripts]]<br />
* [[Compiler specific flags]]<br />
<br />
=== Known Issues ===<br />
* '''[https://gcc.gnu.org/wiki/GFortran gfortran] 4.4 or earlier versions'''<br>Yambo 5.x uses different Fortran constructs, as for example "allocate(x, source=y)", that are not supported by gfortran 4.4 and its earlier versions, please update your gfortran or use a different compiler.<br />
<br />
* '''NetCDF/HDF5 in Ubuntu 20.4'''<br>System provided NetCDF and HDF5 libraries in LinuxMint 20.1/Ubuntu 20.4 have problems with Yambo please use internal Yambo libraries<br />
<br />
* '''Quantum-Espresso at GAMMA point'''<br> In Quantum-Espresso if you perform a SCF calculation using the option "KPOINTS gamma" you should use the same option for the NSCF otherwise Yambo gets confused with the g-vectors. If you need more k-points in the NSCF just re-run the SCF with "KPOINTS automatic /1 1 1 0 0 0" and the run NSCF with a finite k-grid<br />
<br />
* '''Internal MAC-OSX libraries'''<br> At present it is no possible to compile Yambo with internal macos libraries Indeed, no include/system/netcdf.mod file is present in the system. The problem is due to Autoconf setting which automatically searches for versions of the needed libraries in your system despite the specific options given to configure. Then, it would compile the internal hdf5, then find an external netcdf, then try to compile netcdf-fortran creating various conflicts. <br />
<br />
* '''gfortran compiler on MAC-OSX'''<br> There are different problems compiling Yambo with "gfortran" variant of the compiler/libraries with MacPorts, a possible solution it is to install the "gcc8" variant of these libraries and compilters. <br>More details here: [http://www.yambo-code.eu/forum/viewtopic.php?t=1767 http://www.yambo-code.eu/forum/viewtopic.php?t=1767]<br />
<br />
* '''Input file generation on MacOSX'''<br> There are two issues on input file generation: 1) when you generate an input file on MacOSX Yambo is not able to read values already present in the input file, and reset them to the default value; 2) if yambo and ypp have the same option to generate an input file the code get confused. Please use long input strings, for example "yambo -optics" instead of "yambo -o".<br />
<br />
* '''Parallel compilation with nvfortran for nproc >=8 ''' <br> Compiling yambo in parallel with nvfortran and 8 or more processor give some problem. Please compile with less processors</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Installation&diff=6278Installation2023-03-29T10:18:15Z<p>Nicolaspallanzani: /* Custom Configuration */</p>
<hr />
<div>=== Download ===<br />
<br />
The Yambo source code can be downloaded from several sources. Refer to the [[Download|dedicated page]] for further informations.<br />
<br />
=== Quick Configuration (with long compilation) ===<br />
<br />
Yambo can make good use of external libraries like FFTW, LAPACK, netCDF, HDF5, IOTK, LIBXC and so on. It is worth identifying if they are already installed on your system, especially for HPC machines.<br />
<br />
If you are lucky, the configure script will successfully find the best compiler options. Moving in the source directory you can configure quickly Yambo and start the compilation simply with these two commands:<br />
<br />
% ./configure<br />
% make core<br />
<br />
This leads to a very long compilation because Yambo will download and compile all the required libraries. Executables are found in the <tt>bin</tt> folder. To check that it works:<br />
<br />
% ./bin/yambo<br />
<br />
Cannot access CORE database (SAVE/*db1 and/or SAVE/*wf)<br />
<br />
This is the expected error message since we didn't provide the input database needed by Yambo.<br />
<br />
=== Custom Configuration ===<br />
<br />
In general, however, some fine-tuning will be necessary to link the requested libraries. <br />
It is also possible to customize the configurazion using configure options that allow you to enable or disable some features. In order to have a complete list of all those options use the command<br />
<br />
./configure --help<br />
<br />
After configure, you can also edit the <code>config/setup</code> file.<br />
<br />
If you want to install yambo on your local machine or just for testing/tutorial purposes, you can start with the configure options suggested here:<br />
<br />
--enable-mpi # already enabled by default<br />
--enable-open-mp<br />
<br />
to enable MPI and OpenMP parallelizarion;<br />
<br />
--enable-time-profile<br />
--enable-memory-profile<br />
<br />
to enable time and memory profiling (very useful for benchmarking and debugging);<br />
<br />
--enable-par-linalg<br />
--enable-slepc-linalg<br />
<br />
to enable rispectively the support to the parallel (with ScaLAPACK) linear algebra and the suport for the diagonalization of BSE using SLEPc library;<br />
<br />
--with-extlibs-path=<path><br />
<br />
to specify a directory where Yambo will install the needed external libraries (replace <code><path></code> with a valid directory path where you have write permissions);<br />
<br />
--enable-cuda=<opts><br />
<br />
to enable CUDA-Fortran support, where <code><opts></code> are the CUDA version and the compute capability of the NVidia device (e.g. <code>cuda11.0,cc70</code>). Please consider this last option only if you are sure that your machine have a GPU CUDA-capable.<br />
<br />
==== About external libraries ====<br />
<br />
Usually in HPC systems you can find already installed the library needed by Yambo. So you can use them through the specific configure options. Here below some examples.<br />
<br />
In order to link to a specific installation of a library you can use the relative configure option and specify the path:<br />
<br />
--with-hdf5-path=</path/to/hdf5><br />
--with-netcdf-path=</path/to/netcdf-c><br />
--with-netcdff-path=</path/to/netcdf-fortran><br />
<br />
Here and example on how to use an installation of the Intel MKL libraries for the linear algebra and the Fourier transformations:<br />
<br />
--with-blas-libs="-L${MKLROOT}/lib/intel64 -lmkl_intel_lp64 -lmkl_intel_thread -lmkl_core -liomp5 -lpthread -lm -ldl" \<br />
--with-lapack-libs="-L${MKLROOT}/lib/intel64 -lmkl_intel_lp64 -lmkl_intel_thread -lmkl_core -liomp5 -lpthread -lm -ldl" \<br />
--with-scalapack-libs="-L${MKLROOT}/lib/intel64 -lmkl_scalapack_lp64" \<br />
--with-blacs-libs="-L${MKLROOT}/lib/intel64 -lmkl_blacs_intelmpi_lp64" \<br />
--with-fft-includedir="${MKLROOT}/include" \<br />
--with-fft-libs="-L${MKLROOT}/lib/intel64 -lmkl_intel_lp64 -lmkl_intel_thread -lmkl_core -liomp5 -lpthread -lm -ldl"<br />
<br />
==== About environment variables ====<br />
<br />
Using specific environment variables it is also possible to tell the configuration script the name of the compiler or of the MPI wrapper or other compilation options. Here some examples in case you are using the NVHPC compilers suite:<br />
<br />
./configure CC=nvc FC=nvfortran FPP="nvfortran -Mpreprocess -E" MPIFC=mpif90 ...<br />
<br />
==== Specific Configuration options ====<br />
<br />
Here is a list of specific configuration options.<br />
<br />
* [[configure-5.0|Configure options for yambo 5.0]] <br />
* [[configure-4.4.0|Configure options for Yambo 4.4.0]]<br />
* [[configure options for Yambo v4|Configure options for Yambo v4 and v3]]<br />
<br />
=== Further informations ===<br />
<br />
* [[Install Yambo in IRENE machine (TGCC Joliot Curie)]]<br />
* [[Install Yambo on Ubuntu/LinuxMint]]<br />
* [[Machine specific configure scripts]]<br />
* [[Install Yambo on Ubuntu/LinuxMint with Intel compiler]]<br />
* [[Install Yambo with external HDF5 and NetCDF libraries]]<br />
* [[Install Yambo on Ubuntu/LinuxMint with NVfortran compiler]]<br />
* [[Compile the libraries in Yambo independently]]<br />
<br />
=== Known Issues ===<br />
* '''[https://gcc.gnu.org/wiki/GFortran gfortran] 4.4 or earlier versions'''<br>Yambo 5.x uses different Fortran constructs, as for example "allocate(x, source=y)", that are not supported by gfortran 4.4 and its earlier versions, please update your gfortran or use a different compiler.<br />
<br />
* '''NetCDF/HDF5 in Ubuntu 20.4'''<br>Internal NetCDF and HDF5 libraries in LinuxMint 20.1/Ubuntu 20.4 have problems with Yambo please use internal Yambo libraries<br />
<br />
* '''Quantum-Espresso at GAMMA point'''<br> In Quantum-Espresso if you perform a SCF calculation using the option "KPOINTS gamma" you should use the same option for the NSCF otherwise Yambo gets confused with the g-vectors. If you need more k-points in the NSCF just re-run the SCF with "KPOINTS automatic /1 1 1 0 0 0" and the run NSCF with a finite k-grid<br />
<br />
* '''Internal MAC-OSX libraries'''<br> At present it is no possible to compile Yambo with internal macos libraries Indeed, no include/system/netcdf.mod file is present in the system. The problem is due to Autoconf setting which automatically searches for versions of the needed libraries in your system despite the specific options given to configure. Then, it would compile the internal hdf5, then find an external netcdf, then try to compile netcdf-fortran creating various conflicts. <br />
<br />
* '''gfortran compiler on MAC-OSX'''<br> There are different problems compiling Yambo with "gfortran" variant of the compiler/libraries with MacPorts, a possible solution it is to install the "gcc8" variant of these libraries and compilters. <br>More details here: [http://www.yambo-code.org/forum/viewtopic.php?t=1767 http://www.yambo-code.org/forum/viewtopic.php?t=1767]<br />
<br />
* '''Input file generation on MacOSX'''<br> There are two issues on input file generation: 1) when you generate an input file on MacOSX Yambo is not able to read values already present in the input file, and reset them to the default value; 2) if yambo and ypp have the same option to generate an input file the code get confused. Please use long input strings, for example "yambo -optics" instead of "yambo -o".</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Install_Yambo_on_Ubuntu/LinuxMint&diff=6277Install Yambo on Ubuntu/LinuxMint2023-03-29T10:12:06Z<p>Nicolaspallanzani: </p>
<hr />
<div>Here we can find the instruction to install Yambo 5.1.1 on a standard machine with a [https://ubuntu.com/ Ubuntu]/[https://linuxmint.com/ LinuxMint] distribution.<br />
<br />
We suppose you have root permission on your machine to install all the required packages.<br />
<br />
Run apt-get to update the package list<br />
<br />
apt-get -yqq update <br />
<br />
Install compilers, python, mkl, and all necessary libraries to compile Yambo:<br />
<br />
apt-get install build-essential ca-certificates curl file \<br />
make gcc g++ gfortran git gnupg2 iproute2 \<br />
unzip m4 wget git zlib1g-dev ssh \<br />
libmkl-avx libmkl-avx2 libmkl-avx512 libmkl-core libmkl-def \<br />
libmkl-dev libmkl-gf-ilp64 libmkl-gf-lp64 libmkl-gnu-thread<br />
<br />
<br />
download lastest Yambo release, in this case the 5.1.1:<br />
<br />
wget https://github.com/yambo-code/yambo/archive/5.1.1.tar.gz -O yambo-5.1.1.tar.gz <br />
<br />
decompress the file <br />
<br />
tar zxfv yambo-5.1.1.tar.gz && cd yambo-5.1.1 <br />
<br />
configure Yambo<br />
<br />
./configure --disable-mpi --enable-open-mp \<br />
--enable-slepc-linalg --disable-hdf5-par-io \<br />
--enable-msgs-comps --enable-time-profile --enable-memory-profile \<br />
--with-blas-libs="-L${MKLROOT}/lib/intel64 -Wl,--no-as-needed -lmkl_gf_lp64 -lmkl_gnu_thread -lmkl_core -lgomp -lpthread -lm -ldl" \<br />
--with-lapack-libs="-L${MKLROOT}/lib/intel64 -Wl,--no-as-needed -lmkl_gf_lp64 -lmkl_gnu_thread -lmkl_core -lgomp -lpthread -lm -ldl" <br />
<br />
compile the code (where -j4 means that the code is compiled in parallel on 4 cores):<br />
<br />
make -j4 core<br />
<br />
The compilation was successful if there are the yambo executables in the <code>bin/</code> directory.<br />
<br />
From now the instructions are optional but suggested! You may need sudo privileges to install Yambo in a system directory, otherwise install it in your home space. <br />
<br />
Create a folder to install code and libraries:<br />
<br />
mkdir -p /usr/local/yambo-5.1.1/lib <br />
<br />
copy code and libraries in Yambo folder:<br />
<br />
cp -r bin /usr/local/yambo-5.1.1/ <br />
cp -r lib/external/*/*/lib/*.* /usr/local/yambo-5.1.1/lib/ <br />
cp -r lib/external/*/*/v4/serial/lib/*.* /usr/local/yambo-5.1.1/lib/ <br />
<br />
you can remove the tar.gz file and the Yambo folder (optional):<br />
<br />
cp ..<br />
rm -rf yambo-5.1.1 yambo-5.1.1.tar.gz<br />
<br />
set the path to the Yambo bin folder, for tcsh/csh:<br />
<br />
setenv PATH=/usr/local/yambo-5.1.1/bin:$PATH <br />
setenv LD_LIBRARY_PATH=/usr/local/yambo-5.1.1/lib:$LD_LIBRARY_PATH<br />
<br />
or in bash:<br />
<br />
export PATH=/usr/local/yambo-5.1.1/bin:$PATH <br />
export LD_LIBRARY_PATH=/usr/local/yambo-5.1.1/lib:$LD_LIBRARY_PATH<br />
<br />
you are ready to use Yambo!!!!<br />
<br />
<br><br />
'''Optional for developers'''<br />
<br />
you can copy also the include files:<br />
<br />
mkdir -p /usr/local/yambo-5.1.1/include<br />
cp -r lib/external/*/*/include/*.* /usr/local/yambo-5.1.1/include/ <br />
cp -r lib/external/*/*/v4/serial/include/*.* /usr/local/yambo-5.1.1/include/ <br />
<br />
and can add to the configure the following lines:<br />
<br />
export YAMBO_LIBS=/usr/local/yambo-5.1.1<br />
<br />
and use the following options in the configure:<br />
<br />
--with-iotk-path="${YAMBO_LIBS}" --with-libxc-path="${YAMBO_LIBS}" --with-hdf5-path="${YAMBO_LIBS}" --with-netcdf-path="${YAMBO_LIBS}" --with-netcdff-path="${YAMBO_LIBS}" \<br />
--with-petsc-path="${YAMBO_LIBS}" --with-slepc-path="${YAMBO_LIBS}"<br />
<br />
so the next time you recompile yambo from scrach it will not recompile the libraries.</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Install_Yambo_on_Ubuntu/LinuxMint&diff=6276Install Yambo on Ubuntu/LinuxMint2023-03-29T09:54:56Z<p>Nicolaspallanzani: </p>
<hr />
<div>Here we can find the instruction to install Yambo 5.1.1 on a standard machine with a [https://ubuntu.com/ Ubuntu]/[https://linuxmint.com/ LinuxMint] distribution.<br />
<br />
We suppose you have root permission on your machine to install all the required packages.<br />
<br />
Run apt-get to update the package list<br />
<br />
apt-get -yqq update <br />
<br />
Install compilers, python, mkl, and all necessary libraries to compile Yambo:<br />
<br />
apt-get install build-essential ca-certificates curl file \<br />
make gcc g++ gfortran git gnupg2 iproute2 \<br />
unzip m4 wget git zlib1g-dev ssh \<br />
libmkl-avx libmkl-avx2 libmkl-avx512 libmkl-core libmkl-def \<br />
libmkl-dev libmkl-gf-ilp64 libmkl-gf-lp64 libmkl-gnu-thread<br />
<br />
<br />
download lastest Yambo release, in this case the 5.1.1:<br />
<br />
wget https://github.com/yambo-code/yambo/archive/5.1.1.tar.gz -O yambo-5.1.1.tar.gz <br />
<br />
decompress the file <br />
<br />
tar zxfv yambo-5.1.1.tar.gz && cd yambo-5.1.1 <br />
<br />
configure Yambo<br />
<br />
./configure --disable-mpi --enable-open-mp \<br />
--enable-slepc-linalg --disable-hdf5-par-io \<br />
--enable-msgs-comps --enable-time-profile --enable-memory-profile \<br />
--with-blas-libs="-L${MKLROOT}/lib/intel64 -Wl,--no-as-needed -lmkl_gf_lp64 -lmkl_gnu_thread -lmkl_core -lgomp -lpthread -lm -ldl" \<br />
--with-lapack-libs="-L${MKLROOT}/lib/intel64 -Wl,--no-as-needed -lmkl_gf_lp64 -lmkl_gnu_thread -lmkl_core -lgomp -lpthread -lm -ldl" <br />
<br />
compile the code (where -j4 means that the code is compiled in parallel on 4 cores):<br />
<br />
make -j4 yambo<br />
make -j4 interfaces<br />
make -j4 ypp <br />
<br />
The compilation was successful if there are the yambo executables in the <code>bin/</code> directory.<br />
<br />
From now the instructions are optional but suggested! You may need sudo privileges to install Yambo in a system directory, otherwise install it in your home space. <br />
<br />
Create a folder to install code and libraries:<br />
<br />
mkdir -p /usr/local/yambo-5.0.1/lib <br />
<br />
copy code and libraries in Yambo folder:<br />
<br />
cp -r bin /usr/local/yambo-5.0.1/ <br />
cp -r lib/external/*/*/lib/*.* /usr/local/yambo-5.0.1/lib/ <br />
cp -r lib/external/*/*/v4/serial/lib/*.* /usr/local/yambo-5.0.1/lib/ <br />
<br />
you can remove the tar.gz file and the Yambo folder (optional):<br />
<br />
cp ..<br />
rm -rf yambo-5.0.1 yambo-5.0.1.tar.gz<br />
<br />
set the path to the Yambo bin folder, for tcsh/csh:<br />
<br />
setenv PATH=/usr/local/yambo-5.0.1/bin:$PATH <br />
setenv LD_LIBRARY_PATH=/usr/local/yambo-5.0.1/lib:$LD_LIBRARY_PATH<br />
<br />
or in bash:<br />
<br />
export PATH=/usr/local/yambo-5.0.1/bin:$PATH <br />
export LD_LIBRARY_PATH=/usr/local/yambo-5.0.1/lib:$LD_LIBRARY_PATH<br />
<br />
you are ready to use Yambo!!!!<br />
<br />
<br><br />
'''Optional for developers'''<br />
<br />
you can copy also the include files:<br />
<br />
mkdir -p /usr/local/yambo-5.0.1/include<br />
cp -r lib/external/*/*/include/*.* /usr/local/yambo-5.0.1/include/ <br />
cp -r lib/external/*/*/v4/serial/include/*.* /usr/local/yambo-5.0.1/include/ <br />
<br />
and can add to the configure the following lines:<br />
<br />
export YAMBO_LIBS=/usr/local/yambo-5.0.1/<br />
<br />
and use the following options in the configure:<br />
<br />
--with-iotk-path="${YAMBO_LIBS}" --with-libxc-path="${YAMBO_LIBS}" --with-hdf5-path="${YAMBO_LIBS}" --with-netcdf-path="${YAMBO_LIBS}" --with-netcdff-path="${YAMBO_LIBS}" \<br />
--with-petsc-path="${YAMBO_LIBS}" --with-slepc-path="${YAMBO_LIBS}"<br />
<br />
so the next time you recompile yambo from scrach it will not recompile the libraries.</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Install_Yambo_on_Ubuntu/LinuxMint&diff=6275Install Yambo on Ubuntu/LinuxMint2023-03-29T09:54:14Z<p>Nicolaspallanzani: </p>
<hr />
<div>Here we can find the instruction to install Yambo 5.0.1 on a standard machine with a [https://ubuntu.com/ Ubuntu]/[https://linuxmint.com/ LinuxMint] distribution.<br />
<br />
We suppose you have root permission on your machine to install all the required packages.<br />
<br />
Run apt-get to update the package list<br />
<br />
apt-get -yqq update <br />
<br />
Install compilers, python, mkl, and all necessary libraries to compile Yambo:<br />
<br />
apt-get install build-essential ca-certificates curl file \<br />
make gcc g++ gfortran git gnupg2 iproute2 \<br />
unzip m4 wget git zlib1g-dev ssh \<br />
libmkl-avx libmkl-avx2 libmkl-avx512 libmkl-core libmkl-def \<br />
libmkl-dev libmkl-gf-ilp64 libmkl-gf-lp64 libmkl-gnu-thread<br />
<br />
<br />
download lastest Yambo release, in this case the 5.1.1:<br />
<br />
wget https://github.com/yambo-code/yambo/archive/5.1.1.tar.gz -O yambo-5.1.1.tar.gz <br />
<br />
decompress the file <br />
<br />
tar zxfv yambo-5.1.1.tar.gz && cd yambo-5.1.1 <br />
<br />
configure Yambo<br />
<br />
./configure --disable-mpi --enable-open-mp \<br />
--enable-slepc-linalg --disable-hdf5-par-io \<br />
--enable-msgs-comps --enable-time-profile --enable-memory-profile \<br />
--with-blas-libs="-L${MKLROOT}/lib/intel64 -Wl,--no-as-needed -lmkl_gf_lp64 -lmkl_gnu_thread -lmkl_core -lgomp -lpthread -lm -ldl" \<br />
--with-lapack-libs="-L${MKLROOT}/lib/intel64 -Wl,--no-as-needed -lmkl_gf_lp64 -lmkl_gnu_thread -lmkl_core -lgomp -lpthread -lm -ldl" <br />
<br />
compile the code (where -j4 means that the code is compiled in parallel on 4 cores):<br />
<br />
make -j4 yambo<br />
make -j4 interfaces<br />
make -j4 ypp <br />
<br />
The compilation was successful if there are the yambo executables in the <code>bin/</code> directory.<br />
<br />
From now the instructions are optional but suggested! You may need sudo privileges to install Yambo in a system directory, otherwise install it in your home space. <br />
<br />
Create a folder to install code and libraries:<br />
<br />
mkdir -p /usr/local/yambo-5.0.1/lib <br />
<br />
copy code and libraries in Yambo folder:<br />
<br />
cp -r bin /usr/local/yambo-5.0.1/ <br />
cp -r lib/external/*/*/lib/*.* /usr/local/yambo-5.0.1/lib/ <br />
cp -r lib/external/*/*/v4/serial/lib/*.* /usr/local/yambo-5.0.1/lib/ <br />
<br />
you can remove the tar.gz file and the Yambo folder (optional):<br />
<br />
cp ..<br />
rm -rf yambo-5.0.1 yambo-5.0.1.tar.gz<br />
<br />
set the path to the Yambo bin folder, for tcsh/csh:<br />
<br />
setenv PATH=/usr/local/yambo-5.0.1/bin:$PATH <br />
setenv LD_LIBRARY_PATH=/usr/local/yambo-5.0.1/lib:$LD_LIBRARY_PATH<br />
<br />
or in bash:<br />
<br />
export PATH=/usr/local/yambo-5.0.1/bin:$PATH <br />
export LD_LIBRARY_PATH=/usr/local/yambo-5.0.1/lib:$LD_LIBRARY_PATH<br />
<br />
you are ready to use Yambo!!!!<br />
<br />
<br><br />
'''Optional for developers'''<br />
<br />
you can copy also the include files:<br />
<br />
mkdir -p /usr/local/yambo-5.0.1/include<br />
cp -r lib/external/*/*/include/*.* /usr/local/yambo-5.0.1/include/ <br />
cp -r lib/external/*/*/v4/serial/include/*.* /usr/local/yambo-5.0.1/include/ <br />
<br />
and can add to the configure the following lines:<br />
<br />
export YAMBO_LIBS=/usr/local/yambo-5.0.1/<br />
<br />
and use the following options in the configure:<br />
<br />
--with-iotk-path="${YAMBO_LIBS}" --with-libxc-path="${YAMBO_LIBS}" --with-hdf5-path="${YAMBO_LIBS}" --with-netcdf-path="${YAMBO_LIBS}" --with-netcdff-path="${YAMBO_LIBS}" \<br />
--with-petsc-path="${YAMBO_LIBS}" --with-slepc-path="${YAMBO_LIBS}"<br />
<br />
so the next time you recompile yambo from scrach it will not recompile the libraries.</div>Nicolaspallanzanihttps://wiki.yambo-code.eu/wiki/index.php?title=Installation&diff=6274Installation2023-03-29T09:13:55Z<p>Nicolaspallanzani: /* Custom Configuration */</p>
<hr />
<div>=== Download ===<br />
<br />
The Yambo source code can be downloaded from several sources. Refer to the [[Download|dedicated page]] for further informations.<br />
<br />
=== Quick Configuration (with long compilation) ===<br />
<br />
Yambo can make good use of external libraries like FFTW, LAPACK, netCDF, HDF5, IOTK, LIBXC and so on. It is worth identifying if they are already installed on your system, especially for HPC machines.<br />
<br />
If you are lucky, the configure script will successfully find the best compiler options. Moving in the source directory you can configure quickly Yambo and start the compilation simply with these two commands:<br />
<br />
% ./configure<br />
% make core<br />
<br />
This leads to a very long compilation because Yambo will download and compile all the required libraries. Executables are found in the <tt>bin</tt> folder. To check that it works:<br />
<br />
% ./bin/yambo<br />
<br />
Cannot access CORE database (SAVE/*db1 and/or SAVE/*wf)<br />
<br />
This is the expected error message since we didn't provide the input database needed by Yambo.<br />
<br />
=== Custom Configuration ===<br />
<br />
In general, however, some fine-tuning will be necessary to link the requested libraries. <br />
It is also possible to customize the configurazion using configure options that allow you to enable or disable some features. In order to have a complete list of all those options use the command<br />
<br />
./configure --help<br />
<br />
After configure, you can also edit the <code>config/setup</code> file.<br />
<br />
If you want to install yambo on your local machine or just for testing/tutorial purposes, you can start with the configure options suggested here:<br />
<br />
--enable-mpi # already enabled by default<br />
--enable-open-mp<br />
<br />
to enable MPI and OpenMP parallelizarion;<br />
<br />
--enable-time-profile<br />
--enable-memory-profile<br />
<br />
to enable time and memory profiling (very useful for benchmarking and debugging);<br />
<br />
--enable-par-linalg<br />
--enable-slepc-linalg<br />
<br />
to enable rispectively the support to the parallel (with ScaLAPACK) linear algebra and the suport for the diagonalization of BSE using SLEPc library;<br />
<br />
--enable-cuda=<opts><br />
<br />
to enable CUDA-Fortran support, where <code><opts></code> are the CUDA version and the compute capability of the NVidia device (e.g. <code>cuda11.0,cc70</code>). Please consider this last option only if you are sure that your machine have a GPU CUDA-capable.<br />
<br />
==== About external libraries ====<br />
<br />
Usually in HPC systems you can find already installed the library needed by Yambo. So you can use them through the specific configure options. Here below some examples.<br />
<br />
In order to link to a specific installation of a library you can use the relative configure option and specify the path:<br />
<br />
--with-hdf5-path=</path/to/hdf5><br />
--with-netcdf-path=</path/to/netcdf-c><br />
--with-netcdff-path=</path/to/netcdf-fortran><br />
<br />
Here and example on how to use an installation of the Intel MKL libraries for the linear algebra and the Fourier transformations:<br />
<br />
--with-blas-libs="-L${MKLROOT}/lib/intel64 -lmkl_intel_lp64 -lmkl_intel_thread -lmkl_core -liomp5 -lpthread -lm -ldl" \<br />
--with-lapack-libs="-L${MKLROOT}/lib/intel64 -lmkl_intel_lp64 -lmkl_intel_thread -lmkl_core -liomp5 -lpthread -lm -ldl" \<br />
--with-scalapack-libs="-L${MKLROOT}/lib/intel64 -lmkl_scalapack_lp64" \<br />
--with-blacs-libs="-L${MKLROOT}/lib/intel64 -lmkl_blacs_intelmpi_lp64" \<br />
--with-fft-includedir="${MKLROOT}/include" \<br />
--with-fft-libs="-L${MKLROOT}/lib/intel64 -lmkl_intel_lp64 -lmkl_intel_thread -lmkl_core -liomp5 -lpthread -lm -ldl"<br />
<br />
==== About environment variables ====<br />
<br />
Using specific environment variables it is also possible to tell the configuration script the name of the compiler or of the MPI wrapper or other compilation options. Here some examples in case you are using the NVHPC compilers suite:<br />
<br />
./configure CC=nvc FC=nvfortran FPP="nvfortran -Mpreprocess -E" MPIFC=mpif90 ...<br />
<br />
==== Specific Configuration options ====<br />
<br />
Here is a list of specific configuration options.<br />
<br />
* [[configure-5.0|Configure options for yambo 5.0]] <br />
* [[configure-4.4.0|Configure options for Yambo 4.4.0]]<br />
* [[configure options for Yambo v4|Configure options for Yambo v4 and v3]]<br />
<br />
=== Further informations ===<br />
<br />
* [[Install Yambo in IRENE machine (TGCC Joliot Curie)]]<br />
* [[Install Yambo on Ubuntu/LinuxMint]]<br />
* [[Machine specific configure scripts]]<br />
* [[Install Yambo on Ubuntu/LinuxMint with Intel compiler]]<br />
* [[Install Yambo with external HDF5 and NetCDF libraries]]<br />
* [[Install Yambo on Ubuntu/LinuxMint with NVfortran compiler]]<br />
* [[Compile the libraries in Yambo independently]]<br />
<br />
=== Known Issues ===<br />
* '''[https://gcc.gnu.org/wiki/GFortran gfortran] 4.4 or earlier versions'''<br>Yambo 5.x uses different Fortran constructs, as for example "allocate(x, source=y)", that are not supported by gfortran 4.4 and its earlier versions, please update your gfortran or use a different compiler.<br />
<br />
* '''NetCDF/HDF5 in Ubuntu 20.4'''<br>Internal NetCDF and HDF5 libraries in LinuxMint 20.1/Ubuntu 20.4 have problems with Yambo please use internal Yambo libraries<br />
<br />
* '''Quantum-Espresso at GAMMA point'''<br> In Quantum-Espresso if you perform a SCF calculation using the option "KPOINTS gamma" you should use the same option for the NSCF otherwise Yambo gets confused with the g-vectors. If you need more k-points in the NSCF just re-run the SCF with "KPOINTS automatic /1 1 1 0 0 0" and the run NSCF with a finite k-grid<br />
<br />
* '''Internal MAC-OSX libraries'''<br> At present it is no possible to compile Yambo with internal macos libraries Indeed, no include/system/netcdf.mod file is present in the system. The problem is due to Autoconf setting which automatically searches for versions of the needed libraries in your system despite the specific options given to configure. Then, it would compile the internal hdf5, then find an external netcdf, then try to compile netcdf-fortran creating various conflicts. <br />
<br />
* '''gfortran compiler on MAC-OSX'''<br> There are different problems compiling Yambo with "gfortran" variant of the compiler/libraries with MacPorts, a possible solution it is to install the "gcc8" variant of these libraries and compilters. <br>More details here: [http://www.yambo-code.org/forum/viewtopic.php?t=1767 http://www.yambo-code.org/forum/viewtopic.php?t=1767]<br />
<br />
* '''Input file generation on MacOSX'''<br> There are two issues on input file generation: 1) when you generate an input file on MacOSX Yambo is not able to read values already present in the input file, and reset them to the default value; 2) if yambo and ypp have the same option to generate an input file the code get confused. Please use long input strings, for example "yambo -optics" instead of "yambo -o".</div>Nicolaspallanzani