Sld 2026

hdr/anisotropy.hpp

@@ -3,9 +3,10 @@
 //   This file is part of the VAMPIRE open source package under the
 //   Free BSD licence (see licence file for details).
 //
-//   (c) Sam Westmoreland 2016. All rights reserved.
+//   (c) Jack Collings and Sam Westmoreland 2016. All rights reserved.
 //
 //   Email: sw766@york.ac.uk
+//          jbc525@york.ac.uk
 //
 //------------------------------------------------------------------------------
 //
@@ -26,6 +27,15 @@
 //--------------------------------------------------------------------------------
 namespace anisotropy
 {
+   //-----------------------------------------------------------------------------
+   // Function to check orthogonality, set orthonormality and generate last
+   // last anisotropy vector
+   //-----------------------------------------------------------------------------
+   void set_anisotropy_vectors(  std::vector<double>& v1, 
+                                 std::vector<double>& v2,
+                                 std::vector<double>& v3,
+                                 int mat);
+
    //-----------------------------------------------------------------------------
    // function to initialize anisotropy module
    //-----------------------------------------------------------------------------
@@ -57,11 +67,37 @@ namespace anisotropy
    //-----------------------------------------------------------------------------
    double get_anisotropy_constant(const int material);
    double get_ku2(const int material);
+   double get_k2r1(const int material);
+   double get_k2r1_odd(const int material);
+   double get_k2r2(const int material);
+   double get_k2r2_odd(const int material);
    double get_ku4(const int material);
+   double get_k4r1(const int material);
+   double get_k4r1_odd(const int material);
+   double get_k4r2(const int material);
+   double get_k4r2_odd(const int material);
+   double get_k4r3(const int material);
+   double get_k4r3_odd(const int material);
+   double get_k4r4(const int material);
+   double get_k4r4_odd(const int material);
    double get_ku6(const int material);
+   double get_k6r1(const int material);
+   double get_k6r1_odd(const int material);
+   double get_k6r2(const int material);
+   double get_k6r2_odd(const int material);
+   double get_k6r3(const int material);
+   double get_k6r3_odd(const int material);
+   double get_k6r4(const int material);
+   double get_k6r4_odd(const int material);
+   double get_k6r5_odd(const int material);
+   double get_k6r5(const int material);
+   double get_k6r6(const int material);
+   double get_k6r6_odd(const int material);
    double get_kc4(const int material);
    double get_kc6(const int material);
    std::vector<double> get_ku_vector(const int material);
+   std::vector<double> get_kr_vector(const int material);
+   std::vector<double> get_kl_vector(const int material);
 
    //-----------------------------------------------------------------------------
    // function to identify surface atoms

hdr/atoms.hpp

@@ -27,9 +27,14 @@
 
 #include <string>
 #include <vector>
+#include <cstdint>
 
 #include "exchange.hpp"
 
+// Load standard forms of fixed-width types (needed for some compilers)
+using std::uint64_t;
+using std::int64_t;
+
 // unit vector type
 class uvec_t{
    public:
@@ -94,13 +99,17 @@ namespace atoms
 	extern std::vector <double> y_spin_array;
 	extern std::vector <double> z_spin_array;
    extern std::vector <double> m_spin_array; /// Array of atomic spin moments
+   extern std::vector <double> mass_spin_array; /// Array of mass of atoms
 
 	extern std::vector <double> x_total_spin_field_array;		/// Total spin dependent fields
 	extern std::vector <double> y_total_spin_field_array;		/// Total spin dependent fields
 	extern std::vector <double> z_total_spin_field_array;		/// Total spin dependent fields
 	extern std::vector <double> x_total_external_field_array;	/// Total external fields
 	extern std::vector <double> y_total_external_field_array;	/// Total external fields
 	extern std::vector <double> z_total_external_field_array;	/// Total external fields
+	extern std::vector <double> x_thermal_field_array;	/// Total external fields
+	extern std::vector <double> y_thermal_field_array;	/// Total external fields
+	extern std::vector <double> z_thermal_field_array;	/// Total external fields
 
 	extern std::vector <zval_t> i_exchange_list;
 	extern std::vector <zvec_t> v_exchange_list;
@@ -111,6 +120,14 @@ namespace atoms
 
    extern std::vector <uvec_t> neighbour_eij_array; // unrolled list of eij unit vectors between neighbouring atoms
 
+	extern std::vector <double> x_total_spin_forces_array;		/// Total spin dependent fields
+	extern std::vector <double> y_total_spin_forces_array;		/// Total spin dependent fields
+	extern std::vector <double> z_total_spin_forces_array;		/// Total spin dependent fields
+
+	extern std::vector <double> x_velo_array;		/// Total spin dependent fields
+	extern std::vector <double> y_velo_array;		/// Total spin dependent fields
+	extern std::vector <double> z_velo_array;		/// Total spin dependent fields
+
 }
 
 

hdr/category.hpp

@@ -51,6 +51,8 @@ namespace cat{
 		// spin temperature variables
 		double spin_temp;
 		double mean_spin_temp;
+		double SxH2;
+		double SH;
 
 		// member functions
 		category_t(); /// constructor

hdr/cells.hpp

@@ -31,6 +31,7 @@ namespace cells{
    extern double macro_cell_size_x; /// lateral size of local macro-cells (A)
    extern double macro_cell_size_y; /// lateral size of local macro-cells (A)
    extern double macro_cell_size_z; /// lateral size of local macro-cells (A)
+   extern double atomic_volume; // volume of each magnetic moment for atomistic dipole self term
 
    extern std::vector <int> local_cell_array;
    extern std::vector <int> num_atoms_in_cell; /// number of atoms in each cell

hdr/constants.hpp

@@ -20,6 +20,7 @@ namespace constants{
 
    extern const double muB; // Bohr Magneton (Joules / Tesla)
    extern const double kB;  // Boltzmann constant (Joules / Kelvin)
+   extern const double kB_eV; //Boltzmann constant in eV
 
 } // end of exchange namespace
 

hdr/create_atoms_class.hpp

@@ -13,6 +13,12 @@
 #ifndef CREATE_ATOMS_CLASS_H_
 #define CREATE_ATOMS_CLASS_H_
 
+#include <cstdint>
+
+// Load standard forms of fixed-width types (needed for some compilers)
+using std::uint64_t;
+using std::int64_t;
+
 //namespace create{
 namespace cs{
 

hdr/demag.hpp

@@ -34,6 +34,10 @@
 #include <vector>
 #include <cstdint>
 
+// Load standard forms of fixed-width types (needed for some compilers)
+using std::uint64_t;
+using std::int64_t;
+
 namespace demag{
 
    extern bool fast;

hdr/dipole.hpp

@@ -14,6 +14,11 @@
 // C++ standard library headers
 #include <string>
 #include <vector>
+#include <cstdint>
+
+// Load standard forms of fixed-width types (needed for some compilers)
+using std::uint64_t;
+using std::int64_t;
 
 // Vampire headers
 #include "dipole.hpp"

hdr/lsf.hpp

@@ -0,0 +1,50 @@
+//------------------------------------------------------------------------------
+//
+//   This file is part of the VAMPIRE open source package under the
+//   Free BSD licence (see licence file for details).
+//
+//   (c) David R Papp 2024. All rights reserved.
+//
+//------------------------------------------------------------------------------
+//
+
+#ifndef LSF_H_
+#define LSF_H_
+
+/// Header file for LLG namespace
+namespace LSF_arrays{
+
+//==========================================================
+// Namespace to store persistant LSF integration arrays
+//==========================================================
+
+	extern std::vector<double> x_lsf_array;
+	extern std::vector<double> y_lsf_array;
+	extern std::vector<double> z_lsf_array;
+
+	extern std::vector<double> x_euler_array;
+	extern std::vector<double> y_euler_array;
+	extern std::vector<double> z_euler_array;
+
+	extern std::vector<double> x_heun_array;
+	extern std::vector<double> y_heun_array;
+	extern std::vector<double> z_heun_array;
+
+	extern std::vector<double> x_spin_storage_array;
+	extern std::vector<double> y_spin_storage_array;
+	extern std::vector<double> z_spin_storage_array;
+
+	extern std::vector<double> x_initial_spin_array;
+	extern std::vector<double> y_initial_spin_array;
+	extern std::vector<double> z_initial_spin_array;
+
+	extern bool LSF_set;
+
+	extern std::vector<double> mod_S;
+
+	extern std::vector<double> tx;
+	extern std::vector<double> ty;
+	extern std::vector<double> tz;
+
+}
+#endif /*LSF_H_*/

hdr/lsf_mc.hpp

@@ -0,0 +1,23 @@
+//------------------------------------------------------------------------------
+//
+//   This file is part of the VAMPIRE open source package under the
+//   Free BSD licence (see licence file for details).
+//
+//   (c) David R Papp 2024. All rights reserved.
+//
+//------------------------------------------------------------------------------
+//
+
+// Program headers
+#ifndef LSF_MC_H_
+#define LSF_MC_H_
+
+namespace montecarlo{
+
+   // Declare spin vectors
+   extern std::vector<double> mod_S;
+   extern bool mc_set;
+   extern void mcinit();
+
+}
+#endif /*LSF_MC_H_*/

hdr/lsf_rk4.hpp

@@ -0,0 +1,54 @@
+//------------------------------------------------------------------------------
+//
+//   This file is part of the VAMPIRE open source package under the
+//   Free BSD licence (see licence file for details).
+//
+//   (c) David R Papp 2024. All rights reserved.
+//
+//------------------------------------------------------------------------------
+//
+
+#ifndef LSF_RK4_H_
+#define LSF_RK4_H_
+
+// Header file for LSF-RK4 namespace
+namespace LSF_RK4_arrays{
+
+//==========================================================
+// Namespace to store persistant LSF-RK4 integration arrays
+//==========================================================
+
+	extern std::vector<double> x_lsf_array;
+	extern std::vector<double> y_lsf_array;
+	extern std::vector<double> z_lsf_array;
+
+	extern std::vector<double> x_initial_spin_array;
+	extern std::vector<double> y_initial_spin_array;
+	extern std::vector<double> z_initial_spin_array;
+
+	extern std::vector<double> x_k1_array;
+	extern std::vector<double> y_k1_array;
+	extern std::vector<double> z_k1_array;
+
+	extern std::vector<double> x_k2_array;
+	extern std::vector<double> y_k2_array;
+	extern std::vector<double> z_k2_array;
+
+	extern std::vector<double> x_k3_array;
+	extern std::vector<double> y_k3_array;
+	extern std::vector<double> z_k3_array;
+
+	extern std::vector<double> x_k4_array;
+	extern std::vector<double> y_k4_array;
+	extern std::vector<double> z_k4_array;
+
+	extern bool LSF_RK4_set;
+
+	extern std::vector<double> mod_S;
+
+	extern std::vector<double> tx;
+	extern std::vector<double> ty;
+	extern std::vector<double> tz;
+
+}
+#endif /*LSF_RK4_H_*/

hdr/material.hpp

@@ -90,7 +90,9 @@ namespace mp
 		std::vector<bool> override_atomsitic;
 
 		double alpha;
+                double alpha_eq;
 		double mu_s_SI;
+	    double mass;
 		double magnetisation;
 
 		double gamma_rel;
@@ -113,6 +115,9 @@ namespace mp
 		double one_oneplusalpha_sq;
 		double alpha_oneplusalpha_sq;
 		double H_th_sigma;
+//modified SLD M Strungaru
+                double H_th_sigma_eq;
+
 		bool constrained; /// specifies primary or alternate integrator
 
 		double temperature; /// Kelvin

hdr/montecarlo.hpp

@@ -49,6 +49,8 @@ namespace montecarlo{
    int cmc_mc_step();
    void cmc_mc_step_mask();
    void mc_step_parallel(std::vector<double> &x_spin_array, std::vector<double> &y_spin_array, std::vector<double> &z_spin_array, std::vector<int> &type_array);
+   void lsf_mc_step();
+   void lsf_mc_step_parallel(std::vector<double> &x_spin_array, std::vector<double> &y_spin_array, std::vector<double> &z_spin_array, std::vector<int> &type_array);
 
    //---------------------------------------------------------------------------
    // Provide access to CMCinit and CMCMCinit for cmc_anisotropy and
@@ -58,13 +60,16 @@ namespace montecarlo{
    void CMCMCinit();
    void mc_parallel_init(std::vector<double> &x, std::vector<double> &y, std::vector<double> &z,
                          double min_dim[3], double max_dim[3]);
+   void lsf_mc_parallel_init(std::vector<double> &x, std::vector<double> &y, std::vector<double> &z,
+                             double min_dim[3], double max_dim[3]);
 
    void initialise_masked_cmc_mc(const int num_sets,                       // number of sets of constrained and unconstrained atoms
 										   const std::vector<int>& mask,             // unique ID for N sets of atoms with different constraints
 										   const std::vector<bool>& constrained,     // flag to indicate if atom set with mask index is constrained
 										   const std::vector<double>& constraints);  // list of 2N vectors listing constraint angles theta and phi
 
    extern bool mc_parallel_initialized;
+   extern bool lsf_mc_parallel_initialized;
 
    //---------------------------------------------------------------------------
    // Function to perform monte carlo preconditioning

hdr/program.hpp

@@ -71,13 +71,16 @@ namespace program
    extern void mm_A_calculation();
    extern void exchange_stiffness();
 	extern void electrical_pulse();
+	extern void spin_waves(); // JRH
+	extern void field_pulse();
 
 	// Sundry programs and diagnostics not under general release
 	extern int LLB_Boltzmann();
 	extern int timestep_scaling();
 	extern void boltzmann_dist();
   	extern void setting_process();
   	extern void boltzmann_dist_micromagnetic_llg();
+	extern void hamr_cool();
 
 }