cleanup and fixes

Author: louisponet

Project.toml

@@ -2,7 +2,7 @@ name = "DFControl"
 uuid = "1e31e15d-4957-550d-a244-318eced754ae"
 authors = ["Louis Ponet <[email protected]>"]
 repo = "https://github.com/louisponet/DFControl.jl.git"
-version = "0.5.29"
+version = "0.5.30"
 
 [deps]
 ANSIColoredPrinters = "a4c015fc-c6ff-483c-b24f-f7ea428134e9"

src/Client/job.jl

@@ -206,7 +206,7 @@ function RemoteHPC.save(job::Job, workflow = nothing; versioncheck=true, kwargs.
         end
 
         linkpath = joinpath(job, "$el.UPF")
-        if p.path != linkpath || !ispath(server, linkpath)
+        if !ispath(server, linkpath) || p.path != realpath(server, linkpath) 
             if ispath(server, linkpath)
                 rm(server, linkpath)
             end
@@ -394,30 +394,30 @@ function outputdata(job::Job; calcs=map(x->x.name, job.calculations), extra_pars
 end
 
 """
-    bandgap(job::Job, fermi=nothing)
+    bandgap(job::Job, nelec=nothing)
 
 Calculates the bandgap (possibly indirect) around the fermi level.
 Uses the first found bands calculation, if there is none it uses the first found nscf calculation.
 """
-function bandgap(job::Job, fermi = nothing, outdat = outputdata(job))
+function bandgap(job::Job, nelec = nothing, outdat = outputdata(job))
     band_calcs = filter(!isnothing, getfirst.([Calculations.isbands, Calculations.isnscf, Calculations.isscf], (job.calculations,)))
     if isempty(band_calcs)
         error("No valid calculation found to calculate the bandgap.\nMake sure the job has either a valid bands or nscf calculation.")
     end
 
-    if fermi === nothing
-        fermi_calcs = filter(x -> (Calculations.isvcrelax(x) ||
+    if nelec === nothing
+        n_calcs = filter(x -> (Calculations.isvcrelax(x) ||
                                    Calculations.isscf(x) ||
                                    Calculations.isnscf(x)), job.calculations)
 
-        if isempty(fermi_calcs)
-            error("No valid calculation found to extract the fermi level.\nPlease supply the fermi level manually.")
+        if isempty(n_calcs)
+            error("No valid calculation found to extract the number of electrons.\nPlease supply nelec manually.")
         end
-        fermi = maximum(x->get(get(outdat, x.name, Dict()), :fermi, -Inf), fermi_calcs)
+        nelec = maximum(x->get(get(outdat, x.name, Dict()), :fermi, -Inf), n_calcs)
     end
 
     bands = map(x->outdat[x.name][:bands], filter(x -> haskey(outdat, x.name), band_calcs))
-    return minimum(bandgap.(bands, fermi))
+    return minimum(bandgap.(bands, nelec))
 end
 
 """

src/FileIO/qe.jl

@@ -147,6 +147,9 @@ end
 function qe_parse_n_KS(out, line, f)
     return out[:n_KS_states] = parse(Int, split(line)[5])
 end
+function qe_parse_n_electrons(out, line, f)
+    return out[:n_electrons] = round(Int, parse(Float64, split(line)[5]))
+end
 
 function qe_parse_crystal_axes(out, line, f)
     m = Mat3(reshape([parse.(Float64, split(readline(f))[4:6]);
@@ -481,6 +484,7 @@ end
 const QE_PW_PARSE_FUNCTIONS = ["C/m^2" => qe_parse_polarization,
                                "lattice parameter" => qe_parse_lattice_parameter,
                                "number of Kohn-Sham states" => qe_parse_n_KS,
+                               "number of electrons" => qe_parse_n_electrons,
                                "crystal axes" => qe_parse_crystal_axes,
                                "EXX-fraction" => (x, y, z) -> x[:hybrid] = true,
                                "EXX self-consistency reached" => (x,y,z) -> x[:hybrid_converged] = true,

src/Structures/structure.jl

@@ -87,12 +87,14 @@ function update_geometry!(str1::Structure, str2::Structure)
     str1.cell = copy(str2.cell)
     ats2 = str2.atoms
     for at1 in str1.atoms
-        tats2 = filter(y -> y.name == at1.name, ats2)
-        id = findmin(map(x -> norm(x.position_cart - at1.position_cart), tats2))[2]
+        id = findmin(map(x -> norm(x.position_cart - at1.position_cart), ats2))[2]
+        
         if id === nothing
             @error "No atom of the species $(at1.name) found in the second structure"
         end
-        set_position!(at1, tats2[id].position_cryst, str1.cell)
+        
+        set_position!(at1, ats2[id].position_cryst, str1.cell)
+        at1.name = ats2[id].name
     end
     return str1
 end

src/types.jl

@@ -30,11 +30,38 @@ end
 eigvals(band::Band) = band.eigvals
 StructTypes.StructType(::Type{<:AbstractBand}) = StructTypes.Mutable()
 
+"""
+    bandgap(bands::AbstractVector{Band}, n_electrons::Int)
+    bandgap(bands::AbstractVector{Band}, fermi::Float64)
+
+Calculates the bandgap (possibly indirect) around the fermi level.
+"""
+function bandgap(bands::Union{Iterators.Flatten,AbstractVector{<:AbstractBand}},
+                 n_electrons::Int)
+    bands = sort(bands, by = x->maximum(eigvals(x)))
+    if length(bands) < n_electrons+1
+        error("not enough bands for $n_electrons electrons ($(length(bands)) bands)." )
+    end
+    gap = minimum(eigvals(bands[n_electrons+1])) - maximum(eigvals(bands[n_electrons]))
+    return gap < 0 ? 0.0 : gap
+end
+
 """
     bandgap(bands::AbstractVector{Band}, fermi=0.0)
 
 Calculates the bandgap (possibly indirect) around the fermi level.
 """
+function bandgap(bands::Union{Iterators.Flatten,AbstractVector{<:AbstractBand}},
+                 n_electrons::Int)
+    maxbands = sort(bands, by = x->maximum(eigvals(x)))
+    minbands = sort(bands, by = x->minimum(eigvals(x)))
+    if length(bands) < n_electrons+1
+        error("not enough bands for $n_electrons electrons ($(length(bands)) bands)." )
+    end
+    gap = minimum(eigvals(minbands[n_electrons+1])) - maximum(eigvals(maxbands[n_electrons]))
+    return gap < 0 ? 0.0 : gap
+end
+
 function bandgap(bands::Union{Iterators.Flatten,AbstractVector{<:AbstractBand}},
                  fermi = 0.0)
     max_valence = -Inf
@@ -54,8 +81,9 @@ function bandgap(bands::Union{Iterators.Flatten,AbstractVector{<:AbstractBand}},
     end
     return min_conduction - max_valence
 end
+
 function bandgap(u_d_bands::Union{NamedTuple,Tuple}, args...)
-    return bandgap(Iterators.flatten(u_d_bands), args...)
+    return bandgap([u_d_bands.up; u_d_bands.down], args...)
 end
 
 mutable struct TimingData