cesmix-mit / atomisticcomposableworkflows Goto Github PK

Provide easy-to-use CESMIX-aligned case studies. Integrate the latest developments of the Julia atomistic ecosystem and state-of-the-art tools.

Home Page: https://cesmix-mit.github.io/AtomisticComposableWorkflows/dev/

Julia 7.21% Python 0.84% Roff 0.44% Shell 0.20% JetBrains MPS 91.31%

julia molecular-dynamics active-learning composability dft differentiable-programming high-performance-computing interatomic-potentials machine-learning

atomisticcomposableworkflows's People

Contributors

Stargazers

Watchers

atomisticcomposableworkflows's Issues

Incorrect energy block calculation of matrix A in fit-snap.jl

The energy block does not seem to represent the SNAP energy block in a multielement system: TiO2. E.g. the number of columns of the energy block (14) is different from the force block (28). Also, the first column of the left and right energy blocks should be equal to the number of atoms of each type in the configuration (8 Ti and 16 O).

Example of how the first column of the energy block is currently calculated:

julia> evaluate_basis(train_sys[1], train_pars[1])'
1×14 adjoint(::Vector{Float64}) with eltype Float64:
 331776.0  6.48762e5  9.44279e5  9.37241e5  1.2034e6  9.09245e5  …  1.14977e6  1.35237e6  1.38483e6  1.3425e6  1.26222e6

On other hand, the force block seems to be ok. E.g.

julia> evaluate_basis_d(train_sys[1], train_pars[1])[1]'
3×28 adjoint(::Matrix{Float64}) with eltype Float64:
 0.0  -0.100626  -0.345134  -0.401752   -0.847065  …  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0
 0.0  -1.31982   -4.53657   -5.16054   -10.9316       0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0
 0.0   1.09027    3.75512    4.32714     9.18019      0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0

Find more information at InteratomicBasisPotentials.jl/LAMMPS/FitSNAP.

Validate the physical variables of the MD

Once the case study of the active learning workflow has been defined, it will be necessary to validate the physical variables of the MD.

Possible case studies:

Na case study using DFTK.jl (see here)
Generate HfO2/HfB2 data using DFTK.jl based on the experience of other team members. See here.
Reproduce aHfO2 case study introduced here.

Evaluate different systems using the neural version of ACE

Files to perform the experiments are located here.

The documentation on how to perform the experiments is analogous to that of this example.

Datasets are locate in this repository, the dropbox folder of the project, and this project from Argonne LCF. I am currently using:

a-Hfo2-300K-NVT-6000.extxyz
HfO2_cpmd_1000.xyz
HfO2_cpmd_train_0_94_11_7700.xyz
HfO2_relax_1000_989.xyz
HfB2-n24-585.exyz
TiO2_7815.xyz
GaN_md_150K_32atom_2000.extxyz

Should this function be added to InteratomicBasisPotentials.jl?

function InteratomicPotentials.energy_and_force(s::AbstractSystem, p::ACE)
    B = evaluate_basis(s, p.basis_params)
    dB = evaluate_basis_d(s, p.basis_params)
    e = austrip.(B' * p.coefficients * 1u"eV")
    f = [SVector(austrip.(d' * p.coefficients .* 1u"eV/Å")...) for d in dB]
    return (; e, f)
end

MD simulations (example here) do not seem to work if it is not added.

See current implementation

Use DFTK.jl to generate Hf+O2 and HfB2+O2 data.

Generate CESMIX data using DFTK.jl and integrate with AL workflows. Leverage the expertise of other team members to generate data for:

Hf + O2, surface oxidation + bulk diffusion,
HfB2+ O2, chemisorption + physisorption

Integrate this on new AL workflows. See here.

Error in run-md-ahfo2-ace-molly.jl

The scripts run-md-ahfo2-ace-nbs.jl and run-md-ahfo2-ace-molly.jl, load a DFT dataset, define a basis potential (ACE), and then run an MD simulation using NBS and Molly, respectively. The NBS script finishes without errors, but the Molly script gives the error shown below. The dataset used in this example is located here

julia> include("run-md-ahfo2-ace-molly.jl")
ERROR: LoadError: MethodError: Cannot `convert` an object of type Missing to an object of type Int16
Closest candidates are:
  convert(::Type{T}, ::LLVM.GenericValue) where T<:Signed at ~/.julia/packages/LLVM/WjSQG/src/execution.jl:27
  convert(::Type{T}, ::LLVM.ConstantInt) where T<:Signed at ~/.julia/packages/LLVM/WjSQG/src/core/value/constant.jl:89
  convert(::Type{T}, ::Ptr) where T<:Integer at /opt/julia-1.7.3/share/julia/base/pointer.jl:23
  ...
Stacktrace:
  [1] JuLIP.Chemistry.AtomicNumber(z::Missing)
    @ JuLIP.Chemistry ~/.julia/packages/JuLIP/2c6VG/src/chemistry.jl:21
  [2] _broadcast_getindex_evalf
    @ ./broadcast.jl:670 [inlined]
  [3] _broadcast_getindex
    @ ./broadcast.jl:643 [inlined]
  [4] getindex
    @ ./broadcast.jl:597 [inlined]
  [5] copy
    @ ./broadcast.jl:899 [inlined]
  [6] materialize(bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, Type{JuLIP.Chemistry.AtomicNumber}, Tuple{Vector{Missing}}})
    @ Base.Broadcast ./broadcast.jl:860
  [7] convert_system_to_atoms(system::System{3, false, Float64, Vector{Molly.Atom{Float64, Quantity{Float64, 𝐌, Unitful.FreeUnits{(u,), 𝐌, nothing}}, Quantity{Float64, 𝐋, Unitful.FreeUnits{(nm,), 𝐋, nothing}}, Quantity{Float64, 𝐋^2 𝐌 𝐍^-1 𝐓^-2, Unitful.FreeUnits{(kJ, mol^-1), 𝐋^2 𝐌 𝐍^-1 𝐓^-2, nothing}}}}, Vector{Atomistic.AugmentedAtomData}, Tuple{}, Tuple{}, Tuple{Atomistic.InteratomicPotentialInter{ACE, Quantity{Float64, 𝐋^2 𝐌 𝐓^-2, Unitful.FreeUnits{(Eₕ,), 𝐋^2 𝐌 𝐓^-2, nothing}}}}, Vector{SVector{3, Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}}}, Vector{SVector{3, Quantity{Float64, 𝐋 𝐓^-1, Unitful.FreeUnits{(a₀, s^-1), 𝐋 𝐓^-1, nothing}}}}, SVector{3, Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}}, NoNeighborFinder, Dict{String, Any}, Unitful.FreeUnits{(a₀^-1, Eₕ), 𝐋 𝐌 𝐓^-2, nothing}, Unitful.FreeUnits{(Eₕ,), 𝐋^2 𝐌 𝐓^-2, nothing}})
    @ InteratomicBasisPotentials ~/.julia/packages/InteratomicBasisPotentials/48zq8/src/types/ACE/ace.jl:20
  [8] evaluate_basis(A::System{3, false, Float64, Vector{Molly.Atom{Float64, Quantity{Float64, 𝐌, Unitful.FreeUnits{(u,), 𝐌, nothing}}, Quantity{Float64, 𝐋, Unitful.FreeUnits{(nm,), 𝐋, nothing}}, Quantity{Float64, 𝐋^2 𝐌 𝐍^-1 𝐓^-2, Unitful.FreeUnits{(kJ, mol^-1), 𝐋^2 𝐌 𝐍^-1 𝐓^-2, nothing}}}}, Vector{Atomistic.AugmentedAtomData}, Tuple{}, Tuple{}, Tuple{Atomistic.InteratomicPotentialInter{ACE, Quantity{Float64, 𝐋^2 𝐌 𝐓^-2, Unitful.FreeUnits{(Eₕ,), 𝐋^2 𝐌 𝐓^-2, nothing}}}}, Vector{SVector{3, Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}}}, Vector{SVector{3, Quantity{Float64, 𝐋 𝐓^-1, Unitful.FreeUnits{(a₀, s^-1), 𝐋 𝐓^-1, nothing}}}}, SVector{3, Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}}, NoNeighborFinder, Dict{String, Any}, Unitful.FreeUnits{(a₀^-1, Eₕ), 𝐋 𝐌 𝐓^-2, nothing}, Unitful.FreeUnits{(Eₕ,), 𝐋^2 𝐌 𝐓^-2, nothing}}, ace_params::ACEParams)
    @ InteratomicBasisPotentials ~/.julia/packages/InteratomicBasisPotentials/48zq8/src/types/ACE/ace.jl:27
  [9] energy_and_force(s::System{3, false, Float64, Vector{Molly.Atom{Float64, Quantity{Float64, 𝐌, Unitful.FreeUnits{(u,), 𝐌, nothing}}, Quantity{Float64, 𝐋, Unitful.FreeUnits{(nm,), 𝐋, nothing}}, Quantity{Float64, 𝐋^2 𝐌 𝐍^-1 𝐓^-2, Unitful.FreeUnits{(kJ, mol^-1), 𝐋^2 𝐌 𝐍^-1 𝐓^-2, nothing}}}}, Vector{Atomistic.AugmentedAtomData}, Tuple{}, Tuple{}, Tuple{Atomistic.InteratomicPotentialInter{ACE, Quantity{Float64, 𝐋^2 𝐌 𝐓^-2, Unitful.FreeUnits{(Eₕ,), 𝐋^2 𝐌 𝐓^-2, nothing}}}}, Vector{SVector{3, Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}}}, Vector{SVector{3, Quantity{Float64, 𝐋 𝐓^-1, Unitful.FreeUnits{(a₀, s^-1), 𝐋 𝐓^-1, nothing}}}}, SVector{3, Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}}, NoNeighborFinder, Dict{String, Any}, Unitful.FreeUnits{(a₀^-1, Eₕ), 𝐋 𝐌 𝐓^-2, nothing}, Unitful.FreeUnits{(Eₕ,), 𝐋^2 𝐌 𝐓^-2, nothing}}, p::ACE)
    @ Main ~/Data/repos/JuliaLab/projects/CESMIX-PASAAP/JuliaAtomisticSuiteForCESMIX/ComposableWorkflows/ACE/run-md-ahfo2-ace-molly.jl:59
 [10] potential_energy
    @ ~/.julia/packages/InteratomicPotentials/AOxZJ/src/types/abstract_potential.jl:8 [inlined]
 [11] potential_energy(inter::Atomistic.InteratomicPotentialInter{ACE, Quantity{Float64, 𝐋^2 𝐌 𝐓^-2, Unitful.FreeUnits{(Eₕ,), 𝐋^2 𝐌 𝐓^-2, nothing}}}, sys::System{3, false, Float64, Vector{Molly.Atom{Float64, Quantity{Float64, 𝐌, Unitful.FreeUnits{(u,), 𝐌, nothing}}, Quantity{Float64, 𝐋, Unitful.FreeUnits{(nm,), 𝐋, nothing}}, Quantity{Float64, 𝐋^2 𝐌 𝐍^-1 𝐓^-2, Unitful.FreeUnits{(kJ, mol^-1), 𝐋^2 𝐌 𝐍^-1 𝐓^-2, nothing}}}}, Vector{Atomistic.AugmentedAtomData}, Tuple{}, Tuple{}, Tuple{Atomistic.InteratomicPotentialInter{ACE, Quantity{Float64, 𝐋^2 𝐌 𝐓^-2, Unitful.FreeUnits{(Eₕ,), 𝐋^2 𝐌 𝐓^-2, nothing}}}}, Vector{SVector{3, Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}}}, Vector{SVector{3, Quantity{Float64, 𝐋 𝐓^-1, Unitful.FreeUnits{(a₀, s^-1), 𝐋 𝐓^-1, nothing}}}}, SVector{3, Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}}, NoNeighborFinder, Dict{String, Any}, Unitful.FreeUnits{(a₀^-1, Eₕ), 𝐋 𝐌 𝐓^-2, nothing}, Unitful.FreeUnits{(Eₕ,), 𝐋^2 𝐌 𝐓^-2, nothing}}, neighbors::Nothing)
    @ Atomistic ~/.julia/packages/Atomistic/INc7Q/src/implementations/molly/molly_simulator.jl:81
 [12] potential_energy(s::System{3, false, Float64, Vector{Molly.Atom{Float64, Quantity{Float64, 𝐌, Unitful.FreeUnits{(u,), 𝐌, nothing}}, Quantity{Float64, 𝐋, Unitful.FreeUnits{(nm,), 𝐋, nothing}}, Quantity{Float64, 𝐋^2 𝐌 𝐍^-1 𝐓^-2, Unitful.FreeUnits{(kJ, mol^-1), 𝐋^2 𝐌 𝐍^-1 𝐓^-2, nothing}}}}, Vector{Atomistic.AugmentedAtomData}, Tuple{}, Tuple{}, Tuple{Atomistic.InteratomicPotentialInter{ACE, Quantity{Float64, 𝐋^2 𝐌 𝐓^-2, Unitful.FreeUnits{(Eₕ,), 𝐋^2 𝐌 𝐓^-2, nothing}}}}, Vector{SVector{3, Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}}}, Vector{SVector{3, Quantity{Float64, 𝐋 𝐓^-1, Unitful.FreeUnits{(a₀, s^-1), 𝐋 𝐓^-1, nothing}}}}, SVector{3, Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}}, NoNeighborFinder, Dict{String, Any}, Unitful.FreeUnits{(a₀^-1, Eₕ), 𝐋 𝐌 𝐓^-2, nothing}, Unitful.FreeUnits{(Eₕ,), 𝐋^2 𝐌 𝐓^-2, nothing}}, neighbors::Nothing)
    @ Molly ~/.julia/packages/Molly/uTbm5/src/energy.jl:142
 [13] log_property!(logger::PotentialEnergyLogger{Quantity{Float64, 𝐋^2 𝐌 𝐓^-2, Unitful.FreeUnits{(Eₕ,), 𝐋^2 𝐌 𝐓^-2, nothing}}}, s::System{3, false, Float64, Vector{Molly.Atom{Float64, Quantity{Float64, 𝐌, Unitful.FreeUnits{(u,), 𝐌, nothing}}, Quantity{Float64, 𝐋, Unitful.FreeUnits{(nm,), 𝐋, nothing}}, Quantity{Float64, 𝐋^2 𝐌 𝐍^-1 𝐓^-2, Unitful.FreeUnits{(kJ, mol^-1), 𝐋^2 𝐌 𝐍^-1 𝐓^-2, nothing}}}}, Vector{Atomistic.AugmentedAtomData}, Tuple{}, Tuple{}, Tuple{Atomistic.InteratomicPotentialInter{ACE, Quantity{Float64, 𝐋^2 𝐌 𝐓^-2, Unitful.FreeUnits{(Eₕ,), 𝐋^2 𝐌 𝐓^-2, nothing}}}}, Vector{SVector{3, Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}}}, Vector{SVector{3, Quantity{Float64, 𝐋 𝐓^-1, Unitful.FreeUnits{(a₀, s^-1), 𝐋 𝐓^-1, nothing}}}}, SVector{3, Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}}, NoNeighborFinder, Dict{String, Any}, Unitful.FreeUnits{(a₀^-1, Eₕ), 𝐋 𝐌 𝐓^-2, nothing}, Unitful.FreeUnits{(Eₕ,), 𝐋^2 𝐌 𝐓^-2, nothing}}, neighbors::Nothing, step_n::Int64; kwargs::Base.Pairs{Symbol, Bool, Tuple{Symbol}, NamedTuple{(:parallel,), Tuple{Bool}}})
    @ Molly ~/.julia/packages/Molly/uTbm5/src/loggers.jl:209
 [14] run_loggers!(s::System{3, false, Float64, Vector{Molly.Atom{Float64, Quantity{Float64, 𝐌, Unitful.FreeUnits{(u,), 𝐌, nothing}}, Quantity{Float64, 𝐋, Unitful.FreeUnits{(nm,), 𝐋, nothing}}, Quantity{Float64, 𝐋^2 𝐌 𝐍^-1 𝐓^-2, Unitful.FreeUnits{(kJ, mol^-1), 𝐋^2 𝐌 𝐍^-1 𝐓^-2, nothing}}}}, Vector{Atomistic.AugmentedAtomData}, Tuple{}, Tuple{}, Tuple{Atomistic.InteratomicPotentialInter{ACE, Quantity{Float64, 𝐋^2 𝐌 𝐓^-2, Unitful.FreeUnits{(Eₕ,), 𝐋^2 𝐌 𝐓^-2, nothing}}}}, Vector{SVector{3, Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}}}, Vector{SVector{3, Quantity{Float64, 𝐋 𝐓^-1, Unitful.FreeUnits{(a₀, s^-1), 𝐋 𝐓^-1, nothing}}}}, SVector{3, Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}}, NoNeighborFinder, Dict{String, Any}, Unitful.FreeUnits{(a₀^-1, Eₕ), 𝐋 𝐌 𝐓^-2, nothing}, Unitful.FreeUnits{(Eₕ,), 𝐋^2 𝐌 𝐓^-2, nothing}}, neighbors::Nothing, step_n::Int64; parallel::Bool)
    @ Molly ~/.julia/packages/Molly/uTbm5/src/loggers.jl:22
 [15] simulate!(sys::System{3, false, Float64, Vector{Molly.Atom{Float64, Quantity{Float64, 𝐌, Unitful.FreeUnits{(u,), 𝐌, nothing}}, Quantity{Float64, 𝐋, Unitful.FreeUnits{(nm,), 𝐋, nothing}}, Quantity{Float64, 𝐋^2 𝐌 𝐍^-1 𝐓^-2, Unitful.FreeUnits{(kJ, mol^-1), 𝐋^2 𝐌 𝐍^-1 𝐓^-2, nothing}}}}, Vector{Atomistic.AugmentedAtomData}, Tuple{}, Tuple{}, Tuple{Atomistic.InteratomicPotentialInter{ACE, Quantity{Float64, 𝐋^2 𝐌 𝐓^-2, Unitful.FreeUnits{(Eₕ,), 𝐋^2 𝐌 𝐓^-2, nothing}}}}, Vector{SVector{3, Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}}}, Vector{SVector{3, Quantity{Float64, 𝐋 𝐓^-1, Unitful.FreeUnits{(a₀, s^-1), 𝐋 𝐓^-1, nothing}}}}, SVector{3, Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}}, NoNeighborFinder, Dict{String, Any}, Unitful.FreeUnits{(a₀^-1, Eₕ), 𝐋 𝐌 𝐓^-2, nothing}, Unitful.FreeUnits{(Eₕ,), 𝐋^2 𝐌 𝐓^-2, nothing}}, sim::VelocityVerlet{Quantity{Float64, 𝐓, Unitful.FreeUnits{(fs,), 𝐓, nothing}}, AndersenThermostat{Float64, Float64}}, n_steps::Int64; parallel::Bool)
    @ Molly ~/.julia/packages/Molly/uTbm5/src/simulators.jl:131
 [16] simulate!(sys::System{3, false, Float64, Vector{Molly.Atom{Float64, Quantity{Float64, 𝐌, Unitful.FreeUnits{(u,), 𝐌, nothing}}, Quantity{Float64, 𝐋, Unitful.FreeUnits{(nm,), 𝐋, nothing}}, Quantity{Float64, 𝐋^2 𝐌 𝐍^-1 𝐓^-2, Unitful.FreeUnits{(kJ, mol^-1), 𝐋^2 𝐌 𝐍^-1 𝐓^-2, nothing}}}}, Vector{Atomistic.AugmentedAtomData}, Tuple{}, Tuple{}, Tuple{Atomistic.InteratomicPotentialInter{ACE, Quantity{Float64, 𝐋^2 𝐌 𝐓^-2, Unitful.FreeUnits{(Eₕ,), 𝐋^2 𝐌 𝐓^-2, nothing}}}}, Vector{SVector{3, Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}}}, Vector{SVector{3, Quantity{Float64, 𝐋 𝐓^-1, Unitful.FreeUnits{(a₀, s^-1), 𝐋 𝐓^-1, nothing}}}}, SVector{3, Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}}, NoNeighborFinder, Dict{String, Any}, Unitful.FreeUnits{(a₀^-1, Eₕ), 𝐋 𝐌 𝐓^-2, nothing}, Unitful.FreeUnits{(Eₕ,), 𝐋^2 𝐌 𝐓^-2, nothing}}, sim::VelocityVerlet{Quantity{Float64, 𝐓, Unitful.FreeUnits{(fs,), 𝐓, nothing}}, AndersenThermostat{Float64, Float64}}, n_steps::Int64)
    @ Molly ~/.julia/packages/Molly/uTbm5/src/simulators.jl:130
 [17] simulate(system::FlexibleSystem{3, AtomsBase.Atom, Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}}, simulator::MollySimulator{VelocityVerlet, Quantity{Float64, 𝐓, Unitful.FreeUnits{(fs,), 𝐓, nothing}}, AndersenThermostat{Float64, Float64}}, potential::ACE)
    @ Atomistic ~/.julia/packages/Atomistic/INc7Q/src/implementations/molly/molly_simulator.jl:58
 [18] top-level scope
    @ ./timing.jl:220
 [19] include(fname::String)
    @ Base.MainInclude ./client.jl:451
 [20] top-level scope
    @ REPL[1]:1
in expression starting at /home/elujan/Data/repos/JuliaLab/projects/CESMIX-PASAAP/JuliaAtomisticSuiteForCESMIX/ComposableWorkflows/ACE/run-md-ahfo2-ace-molly.jl:70

Integrating DFTK.jl into the active learning workflow

The purpose of the implementation of this script is to define a basic active learning workflow that integrates the tools we are developing. It needs to be gradually improved. In particular, the function get_dft_data should generate the data for the fitting process. The interatomic potential used in the script is ACE. It would be desirable to integrate DFTK.jl into the active learning workflow by implementing the aforementioned function. Any system that can be used with ACE and aligns with CESMIX objectives is suitable for this instance.

Improve documentation

Use Documenter.jl of something equivalent.

Error in fit-snap.jl when computing force descriptors

ERROR: LoadError: BoundsError: attempt to access 2×55 Matrix{Float64} at index [20, 1:55]
Stacktrace:
  [1] throw_boundserror(A::Matrix{Float64}, I::Tuple{Int64, Base.Slice{Base.OneTo{Int64}}})
    @ Base ./abstractarray.jl:691
  [2] checkbounds
    @ ./abstractarray.jl:656 [inlined]
  [3] _getindex
    @ ./multidimensional.jl:838 [inlined]
  [4] getindex
    @ ./abstractarray.jl:1218 [inlined]
  [5] compute_duarray(x::Float64, y::Float64, z::Float64, z0::Float64, r::Float64, dz0dr::Float64, wj::Float64, rcut::Float64, jj::Int64, snap::SNAPParams{Int64, Float64}, runtime_arrays::InteratomicBasisPotentials.RuntimeArrays{AbstractFloat})
    @ InteratomicBasisPotentials ~/.julia/packages/InteratomicBasisPotentials/48zq8/src/types/SNAP/utilities/compute_ui.jl:218
  [6] compute_duidrj(rij::StaticArraysCore.SVector{3, AbstractFloat}, wj::Float64, rcut::Float64, jj::Int64, snap::SNAPParams{Int64, Float64}, runtime_arrays::InteratomicBasisPotentials.RuntimeArrays{AbstractFloat})
    @ InteratomicBasisPotentials ~/.julia/packages/InteratomicBasisPotentials/48zq8/src/types/SNAP/utilities/compute_ui.jl:343
  [7] evaluate_basis_d(A::FlexibleSystem{3, Atom, Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}}, snap::SNAPParams{Int64, Float64})
    @ InteratomicBasisPotentials ~/.julia/packages/InteratomicBasisPotentials/48zq8/src/types/SNAP/snap.jl:67
  [8] _broadcast_getindex_evalf
    @ ./broadcast.jl:670 [inlined]
  [9] _broadcast_getindex
    @ ./broadcast.jl:643 [inlined]
 [10] getindex
    @ ./broadcast.jl:597 [inlined]
 [11] copy
    @ ./broadcast.jl:899 [inlined]
 [12] materialize(bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(evaluate_basis_d), Tuple{Vector{AbstractSystem}, Vector{SNAPParams{Int64, Float64}}}})
    @ Base.Broadcast ./broadcast.jl:860
 [13] calc_dB(sys::Vector{AbstractSystem})
    @ Main ~/Data/repos/JuliaLab/projects/CESMIX-PASAAP/JuliaAtomisticSuiteForCESMIX/AtomisticComposableWorkflows/SNAP/fit-snap.jl:67
 [14] top-level scope
    @ ./timing.jl:299
 [15] include(fname::String)
    @ Base.MainInclude ./client.jl:451
 [16] top-level scope
    @ REPL[1]:1
in expression starting at /home/elujan/Data/repos/JuliaLab/projects/CESMIX-PASAAP/JuliaAtomisticSuiteForCESMIX/AtomisticComposableWorkflows/SNAP/fit-snap.jl:70

Recommend Projects

React

A declarative, efficient, and flexible JavaScript library for building user interfaces.
Vue.js

🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript

TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
TensorFlow

An Open Source Machine Learning Framework for Everyone
Django

The Web framework for perfectionists with deadlines.
Laravel

A PHP framework for web artisans
D3

Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

javascript

JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
web

Some thing interesting about web. New door for the world.
server

A server is a program made to process requests and deliver data to clients.
Machine learning

Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Visualization

Some thing interesting about visualization, use data art
Game

Some thing interesting about game, make everyone happy.

Recommend Org

Facebook

We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft

Open source projects and samples from Microsoft.
Google

Google ❤️ Open Source for everyone.
Alibaba

Alibaba Open Source for everyone
D3

Data-Driven Documents codes.
Tencent

China tencent open source team.