ICODE-ADC/lammps
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Commit modifs before release 1 (03/26/18)

Browse Source
This commit is contained in:
julient31
2018-03-26 13:30:36 -06:00
parent 08bc115380
commit a315599bac
36 changed files with 6660 additions and 598 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
examples/SPIN/bfo/in.spin.bfo
View File

@ -28,9 +28,9 @@ pair_coeff * * pair/spin/me me 4.5 0.000109 1.0 1.0 1.0
neighbor 0.1 bin
neigh_modify every 10 check yes delay 20
fix 1 all force/spin anisotropy 0.0000033 0.0 0.0 1.0
fix 1 all precession/spin anisotropy 0.0000033 0.0 0.0 1.0
fix 2 all langevin/spin 0.0 0.1 21
fix 3 all integration/spin lattice no
fix 3 all nve/spin lattice yes
timestep 0.0002
@ -43,12 +43,12 @@ variable magz equal c_out_mag[3]
variable magnorm equal c_out_mag[4]
variable emag equal c_out_mag[5]
variable tmag equal c_out_mag[6]
variable mag_force equal f_1
thermo_style custom step time v_magnorm v_emag temp etotal
thermo 50
dump 1 all custom 50 dump_spin_BFO.lammpstrj type x y z spx spy spz
compute outsp all property/atom spx spy spz sp fmx fmy fmz
dump 100 all custom 1 dump_bfo.lammpstrj type x y z c_outsp[1] c_outsp[2] c_outsp[3]
run 5000

13
examples/SPIN/cobalt_fcc/in.spin.cobalt_fcc
View File

@ -15,7 +15,7 @@ region box block 0.0 5.0 0.0 5.0 0.0 5.0
create_box 1 box
create_atoms 1 box
# setting mass, mag. moments, and interactions for cobalt
# setting mass, mag. moments, and interactions for fcc cobalt
mass 1 58.93
@ -29,11 +29,10 @@ pair_coeff * * pair/spin/exchange exchange 4.0 0.0446928 0.003496 1.4885
neighbor 0.1 bin
neigh_modify every 10 check yes delay 20
fix 1 all force/spin zeeman 0.0 0.0 0.0 1.0
fix 1 all precession/spin zeeman 0.0 0.0 0.0 1.0
fix 2 all langevin/spin 0.0 0.0 21
fix 3 all integration/spin lattice yes
fix 3 all nve/spin lattice yes
timestep 0.0001
# compute and output options
@ -47,12 +46,12 @@ variable magz equal c_out_mag[3]
variable magnorm equal c_out_mag[4]
variable emag equal c_out_mag[5]
variable tmag equal c_out_mag[6]
variable mag_force equal f_1
thermo_style custom step time v_magnorm v_emag temp etotal
thermo 10
dump 1 all custom 50 dump_cobalt.lammpstrj type x y z spx spy spz
compute outsp all property/atom spx spy spz sp fmx fmy fmz
dump 100 all custom 1 dump_cobalt_fcc.lammpstrj type x y z c_outsp[1] c_outsp[2] c_outsp[3]
run 10000
run 1000

17
examples/SPIN/cobalt_hcp/in.spin.cobalt_hcp
View File

@ -1,4 +1,4 @@
# fcc cobalt in a 3d periodic box
# hcp cobalt in a 3d periodic box
clear
units metal
@ -10,13 +10,12 @@ boundary p p p
# necessary for the serial algorithm (sametag)
atom_modify map array
#lattice hcp 2.5071 2.5071 4.0695
lattice hcp 2.5071
region box block 0.0 5.0 0.0 5.0 0.0 5.0
create_box 1 box
create_atoms 1 box
# setting mass, mag. moments, and interactions for cobalt
# setting mass, mag. moments, and interactions for hcp cobalt
mass 1 58.93
@ -32,11 +31,10 @@ pair_coeff * * pair/spin/exchange exchange 4.0 0.3593 1.135028015e-05 1.06456856
neighbor 0.1 bin
neigh_modify every 10 check yes delay 20
fix 1 all force/spin zeeman 0.01 0.0 0.0 1.0
fix 1 all precession/spin zeeman 0.0 0.0 0.0 1.0
fix 2 all langevin/spin 0.0 0.0 21
fix 3 all integration/spin lattice yes
fix 3 all nve/spin lattice yes
timestep 0.0001
@ -49,12 +47,11 @@ variable magz equal c_out_mag[3]
variable magnorm equal c_out_mag[4]
variable emag equal c_out_mag[5]
variable tmag equal c_out_mag[6]
variable mag_force equal f_1
thermo_style custom step time v_magnorm v_emag temp etotal
thermo 10
dump 1 all custom 50 dump_cobalt.lammpstrj type x y z spx spy spz
run 1000
compute outsp all property/atom spx spy spz sp fmx fmy fmz
dump 100 all custom 1 dump_cobalt_hcp.lammpstrj type x y z c_outsp[1] c_outsp[2] c_outsp[3]
run 20000

13
examples/SPIN/iron/in.spin.iron
View File

@ -22,22 +22,20 @@ mass 1 55.845
set group all spin/random 31 2.2
velocity all create 100 4928459 rot yes dist gaussian
#pair_style hybrid/overlay eam/alloy pair/spin/exchange 4.0 pair/spin/soc/neel 4.0
pair_style hybrid/overlay eam/alloy pair/spin/exchange 3.5
pair_coeff * * eam/alloy ../examples/SPIN/iron/Fe_Mishin2006.eam.alloy Fe
pair_coeff * * pair/spin/exchange exchange 3.4 0.02726 0.2171 1.841
#pair_coeff * * pair/spin/soc/neel neel 4.0 0.003330282 0.864159 2.13731
neighbor 0.1 bin
neigh_modify every 10 check yes delay 20
fix 1 all force/spin zeeman 0.0 0.0 0.0 1.0
fix 1 all precession/spin zeeman 0.0 0.0 0.0 1.0
fix 2 all langevin/spin 0.0 0.0 21
fix 3 all integration/spin lattice yes
fix 3 all nve/spin lattice yes
timestep 0.0001
# compute and output options
compute out_mag all compute/spin
compute out_pe all pe
@ -48,12 +46,11 @@ variable magz equal c_out_mag[3]
variable magnorm equal c_out_mag[4]
variable emag equal c_out_mag[5]
variable tmag equal c_out_mag[6]
variable mag_force equal f_1
thermo_style custom step time v_magnorm v_tmag temp v_emag ke pe etotal
thermo 50
dump 1 all custom 50 dump_iron.lammpstrj type x y z spx spy spz
compute outsp all property/atom spx spy spz sp fmx fmy fmz
dump 100 all custom 1 dump_iron.lammpstrj type x y z c_outsp[1] c_outsp[2] c_outsp[3]
run 100000

10
examples/SPIN/nickel/exchange_fit_fcc_ni/exchange_fcc_ni.dat
View File

@ -1,5 +1,5 @@
2.492 2.803
3.524 0.0816
4.316 0.35
4.983 0.16
5.572 0.0408
2.495 8.3
3.524 -3.99
4.31 0.998
4.99 -0.955
5.56 0.213

25
examples/SPIN/nickel/in.spin.nickel
View File

@ -1,4 +1,4 @@
# fcc cobalt in a 3d periodic box
# fcc nickel in a 3d periodic box
clear
units metal
@ -19,25 +19,24 @@ create_atoms 1 box
mass 1 58.69
set group all spin/random 31 0.6
set group all spin/random 31 0.63
#set group all spin 0.63 0.0 0.0 1.0
velocity all create 100 4928459 rot yes dist gaussian
#pair_style hybrid/overlay eam/alloy pair/spin/exchange 4.0 pair/spin/soc/neel 4.0
pair_style hybrid/overlay eam/alloy pair/spin/exchange 4.0
pair_coeff * * eam/alloy ../examples/SPIN/nickel/Ni99.eam.alloy Ni
pair_coeff * * pair/spin/exchange exchange 4.0 0.009718152197 0.000153 1.243
#pair_coeff * * pair/spin/soc/neel neel 4.0 0.003330282 0.864159 2.13731
pair_coeff * * pair/spin/exchange exchange 4.0 0.50 0.2280246862 1.229983475
neighbor 0.1 bin
neigh_modify every 10 check yes delay 20
fix 1 all force/spin zeeman 0.0 0.0 0.0 1.0
fix 1 all precession/spin zeeman 0.0 0.0 0.0 1.0
fix 2 all langevin/spin 0.0 0.0 21
fix 3 all integration/spin lattice yes
fix 3 all nve/spin lattice yes
timestep 0.0001
# compute and output options
compute out_mag all compute/spin
compute out_pe all pe
@ -48,12 +47,12 @@ variable magz equal c_out_mag[3]
variable magnorm equal c_out_mag[4]
variable emag equal c_out_mag[5]
variable tmag equal c_out_mag[6]
variable mag_force equal f_1
thermo_style custom step time v_magnorm v_emag temp etotal
thermo 10
thermo_style custom step time v_magnorm v_emag temp v_tmag etotal
thermo 50
#dump 1 all custom 50 dump_cobalt.lammpstrj type x y z spx spy spz
compute outsp all property/atom spx spy spz sp fmx fmy fmz
dump 50 all custom 1 dump.lammpstrj type x y z c_outsp[1] c_outsp[2] c_outsp[3] c_outsp[4] c_outsp[5] c_outsp[6] c_outsp[7]
run 1000
run 2000

6006
examples/SPIN/read_restart/Co_PurjaPun_2012.eam.alloy Normal file
View File

File diff suppressed because it is too large Load Diff

31
examples/SPIN/read_restart/in.spin.read_data
View File

@ -1,4 +1,5 @@
<<<<<<< HEAD
<<<<<<< HEAD
# start a spin-lattice simulation from a data file
clear
units metal
@ -12,6 +13,9 @@ atom_modify map array
read_data ../examples/SPIN/read_restart/Norm_randXY_8x8x32.data
=======
=======
# start a spin-lattice simulation from a data file
>>>>>>> Commit modifs before release 1 (03/26/18)
clear
units metal
dimension 3
@ -22,14 +26,17 @@ atom_style spin
# necessary for the serial algorithm (sametag)
atom_modify map array
read_data ../examples/SPIN/Norm_randXY_8x8x32_test.data
<<<<<<< HEAD
>>>>>>> Commit before meeting 032218
=======
read_data ../examples/SPIN/read_restart/Norm_randXY_8x8x32.data
>>>>>>> Commit modifs before release 1 (03/26/18)
mass 1 58.93
# define magneto-mechanical potentials and forces
<<<<<<< HEAD
<<<<<<< HEAD
pair_style hybrid/overlay eam/alloy pair/spin/exchange 4.0
pair_coeff * * eam/alloy ../examples/SPIN/read_restart/Co_PurjaPun_2012.eam.alloy Co
pair_coeff * * pair/spin/exchange exchange 4.0 0.0446928 0.003496 1.4885
@ -49,18 +56,27 @@ pair_style hybrid/overlay eam/alloy pair/spin/exchange 4.0 pair/spin/soc/neel 4.
pair_coeff * * eam/alloy ../examples/SPIN/Co_PurjaPun_2012.eam.alloy Co
pair_coeff * * pair/spin/exchange exchange 4.0 0.0446928 0.003496 1.4885
pair_coeff * * pair/spin/soc/neel neel 4.0 0.003330282 0.864159 2.13731
=======
pair_style hybrid/overlay eam/alloy pair/spin/exchange 4.0
pair_coeff * * eam/alloy ../examples/SPIN/read_restart/Co_PurjaPun_2012.eam.alloy Co
pair_coeff * * pair/spin/exchange exchange 4.0 0.0446928 0.003496 1.4885
>>>>>>> Commit modifs before release 1 (03/26/18)
neighbor 1.0 bin
neigh_modify every 1 check no delay 0
fix 1 all force/spin zeeman 0.0 0.0 0.0 1.0
fix 1 all precession/spin zeeman 0.0 0.0 0.0 1.0
fix 2 all langevin/spin 0.0 0.0 21
fix 3 all integration/spin serial
fix 3 all nve/spin lattice yes
timestep 0.0001
<<<<<<< HEAD
# define outputs
>>>>>>> Commit before meeting 032218
=======
# define outputs and computes
>>>>>>> Commit modifs before release 1 (03/26/18)
compute out_mag all compute/spin
compute out_pe all pe
@ -76,6 +92,7 @@ thermo 10
thermo_style custom step time v_magnorm v_emag v_tmag temp etotal
thermo_modify format float %20.15g
<<<<<<< HEAD
<<<<<<< HEAD
compute outsp all property/atom spx spy spz sp fmx fmy fmz
dump 100 all custom 1 dump.lammpstrj type x y z c_outsp[1] c_outsp[2] c_outsp[3] c_outsp[4] c_outsp[5] c_outsp[6] c_outsp[7]
@ -86,4 +103,10 @@ dump 1 all custom 1 dump.lammpstrj type x y z spx spy spz
run 10000
>>>>>>> Commit before meeting 032218
=======
compute outsp all property/atom spx spy spz sp fmx fmy fmz
dump 100 all custom 1 dump.lammpstrj type x y z c_outsp[1] c_outsp[2] c_outsp[3] c_outsp[4] c_outsp[5] c_outsp[6] c_outsp[7]
run 100
>>>>>>> Commit modifs before release 1 (03/26/18)

13
examples/SPIN/read_restart/in.spin.restart
View File

@ -1,3 +1,4 @@
# start a spin-lattice simulation from a data file
clear
units metal
atom_style spin
@ -25,18 +26,18 @@ set group single_spin spin/random 11 1.72
velocity all create 200 4928459 rot yes dist gaussian
# define magneto-mechanical potentials and forces
pair_style hybrid/overlay eam/alloy pair/spin/exchange 4.0 pair/spin/soc/neel 4.0
pair_style hybrid/overlay eam/alloy pair/spin/exchange 4.0
pair_coeff * * eam/alloy ../examples/SPIN/Co_PurjaPun_2012.eam.alloy Co
pair_coeff * * pair/spin/exchange exchange 4.0 0.0446928 0.003496 1.4885
pair_coeff * * pair/spin/soc/neel neel 4.0 0.003330282 0.864159 2.13731
neighbor 1.0 bin
neigh_modify every 1 check no delay 0
fix 1 all force/spin zeeman 0.0 0.0 0.0 1.0
fix 1 all precession/spin zeeman 0.0 0.0 0.0 1.0
fix 2 all langevin/spin 0.0 0.0 0.0 21
fix 3 all integration/spin serial
fix 3 all nve/spin lattice yes
timestep 0.0001
# define outputs
@ -50,13 +51,13 @@ variable magz equal c_out_mag[4]
variable magnorm equal c_out_mag[5]
variable emag equal c_out_mag[6]
variable tmag equal c_out_mag[7]
variable mag_force equal f_1
thermo 10
thermo_style custom step time v_magnorm v_emag v_tmag temp etotal
thermo_modify format float %20.15g
dump 1 all custom 20 dump.lammpstrj type x y z spx spy spz
compute outsp all property/atom spx spy spz sp fmx fmy fmz
dump 100 all custom 1 dump.lammpstrj type x y z c_outsp[1] c_outsp[2] c_outsp[3] c_outsp[4] c_outsp[5] c_outsp[6] c_outsp[7]
run 1000

58
examples/SPIN/read_restart/in.spin.write_restart Normal file
View File

@ -0,0 +1,58 @@
# fcc cobalt in a 3d periodic box
clear
units metal
atom_style spin
dimension 3
boundary p p p
# necessary for the serial algorithm (sametag)
atom_modify map array
lattice fcc 3.54
region box block 0.0 5.0 0.0 5.0 0.0 5.0
create_box 1 box
create_atoms 1 box
# setting mass, mag. moments, and interactions for cobalt
mass 1 58.93
set group all spin/random 31 1.72
velocity all create 100 4928459 rot yes dist gaussian
pair_style hybrid/overlay eam/alloy pair/spin/exchange 4.0
pair_coeff * * eam/alloy ../examples/SPIN/cobalt_fcc/Co_PurjaPun_2012.eam.alloy Co
pair_coeff * * pair/spin/exchange exchange 4.0 0.0446928 0.003496 1.4885
neighbor 0.1 bin
neigh_modify every 10 check yes delay 20
fix 1 all precession/spin zeeman 0.0 0.0 0.0 1.0
fix 2 all langevin/spin 0.0 0.0 21
fix 3 all nve/spin lattice yes
timestep 0.0001
# compute and output options
compute out_mag all compute/spin
compute out_pe all pe
compute out_ke all ke
compute out_temp all temp
variable magz equal c_out_mag[3]
variable magnorm equal c_out_mag[4]
variable emag equal c_out_mag[5]
variable tmag equal c_out_mag[6]
thermo_style custom step time v_magnorm v_emag temp etotal
thermo 10
compute outsp all property/atom spx spy spz sp fmx fmy fmz
dump 100 all custom 1 dump.lammpstrj type x y z c_outsp[1] c_outsp[2] c_outsp[3] c_outsp[4] c_outsp[5] c_outsp[6] c_outsp[7]
run 10000
write_restart restart_fcc_cobalt.equil

72
src/SPIN/atom_vec_spin.cpp
View File

@ -1,4 +1,5 @@
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
http://lammps.sandia.gov, Sandia National Laboratories
Steve Plimpton, sjplimp@sandia.gov
@ -43,14 +44,13 @@ AtomVecSpin::AtomVecSpin(LAMMPS *lmp) : AtomVec(lmp)
size_forward = 7;
size_reverse = 6;
size_border = 11;
size_border = 10;
size_velocity = 3;
size_data_atom = 9;
size_data_vel = 4;
xcol_data = 4;
forceclearflag = 1;
atom->mumag_flag = 1;
atom->sp_flag = 1;
}
@ -83,7 +83,6 @@ void AtomVecSpin::grow(int n)
// allocating mag. quantities
mumag = memory->grow(atom->mumag,nmax,"atom:mumag");
sp = memory->grow(atom->sp,nmax,4,"atom:sp");
fm = memory->grow(atom->fm,nmax*comm->nthreads,3,"atom:fm");
@ -101,7 +100,7 @@ void AtomVecSpin::grow_reset()
tag = atom->tag; type = atom->type;
mask = atom->mask; image = atom->image;
x = atom->x; v = atom->v; f = atom->f;
mumag = atom->mumag; sp = atom->sp; fm = atom->fm;
sp = atom->sp; fm = atom->fm;
}
@ -122,7 +121,6 @@ void AtomVecSpin::copy(int i, int j, int delflag)
v[j][1] = v[i][1];
v[j][2] = v[i][2];
mumag[j] = mumag[i];
sp[j][0] = sp[i][0];
sp[j][1] = sp[i][1];
sp[j][2] = sp[i][2];
@ -381,7 +379,6 @@ int AtomVecSpin::pack_border(int n, int *list, double *buf,
buf[m++] = ubuf(tag[j]).d;
buf[m++] = ubuf(type[j]).d;
buf[m++] = ubuf(mask[j]).d;
buf[m++] = mumag[j];
buf[m++] = sp[j][0];
buf[m++] = sp[j][1];
buf[m++] = sp[j][2];
@ -405,7 +402,6 @@ int AtomVecSpin::pack_border(int n, int *list, double *buf,
buf[m++] = ubuf(tag[j]).d;
buf[m++] = ubuf(type[j]).d;
buf[m++] = ubuf(mask[j]).d;
buf[m++] = mumag[j];
buf[m++] = sp[j][0];
buf[m++] = sp[j][1];
buf[m++] = sp[j][2];
@ -438,7 +434,6 @@ int AtomVecSpin::pack_border_vel(int n, int *list, double *buf,
buf[m++] = ubuf(tag[j]).d;
buf[m++] = ubuf(type[j]).d;
buf[m++] = ubuf(mask[j]).d;
buf[m++] = mumag[j];
buf[m++] = sp[j][0];
buf[m++] = sp[j][1];
buf[m++] = sp[j][2];
@ -466,7 +461,6 @@ int AtomVecSpin::pack_border_vel(int n, int *list, double *buf,
buf[m++] = ubuf(tag[j]).d;
buf[m++] = ubuf(type[j]).d;
buf[m++] = ubuf(mask[j]).d;
buf[m++] = mumag[j];
buf[m++] = sp[j][0];
buf[m++] = sp[j][1];
buf[m++] = sp[j][2];
@ -487,7 +481,6 @@ int AtomVecSpin::pack_border_vel(int n, int *list, double *buf,
buf[m++] = ubuf(tag[j]).d;
buf[m++] = ubuf(type[j]).d;
buf[m++] = ubuf(mask[j]).d;
buf[m++] = mumag[j];
buf[m++] = sp[j][0];
buf[m++] = sp[j][1];
buf[m++] = sp[j][2];
@ -521,7 +514,6 @@ int AtomVecSpin::pack_border_hybrid(int n, int *list, double *buf)
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = mumag[j];
buf[m++] = sp[j][0];
buf[m++] = sp[j][1];
buf[m++] = sp[j][2];
@ -547,7 +539,6 @@ void AtomVecSpin::unpack_border(int n, int first, double *buf)
tag[i] = (tagint) ubuf(buf[m++]).i;
type[i] = (int) ubuf(buf[m++]).i;
mask[i] = (int) ubuf(buf[m++]).i;
mumag[i] = buf[m++];
sp[i][0] = buf[m++];
sp[i][1] = buf[m++];
sp[i][2] = buf[m++];
@ -577,7 +568,6 @@ void AtomVecSpin::unpack_border_vel(int n, int first, double *buf)
tag[i] = (tagint) ubuf(buf[m++]).i;
type[i] = (int) ubuf(buf[m++]).i;
mask[i] = (int) ubuf(buf[m++]).i;
mumag[i] = buf[m++];
sp[i][0] = buf[m++];
sp[i][1] = buf[m++];
sp[i][2] = buf[m++];
@ -603,7 +593,6 @@ int AtomVecSpin::unpack_border_hybrid(int n, int first, double *buf)
m = 0;
last = first + n;
for (i = first; i < last; i++) {
mumag[i] = buf[m++];
sp[i][0] = buf[m++];
sp[i][1] = buf[m++];
sp[i][2] = buf[m++];
@ -632,7 +621,6 @@ int AtomVecSpin::pack_exchange(int i, double *buf)
buf[m++] = ubuf(mask[i]).d;
buf[m++] = ubuf(image[i]).d;
buf[m++] = mumag[i];
buf[m++] = sp[i][0];
buf[m++] = sp[i][1];
buf[m++] = sp[i][2];
@ -665,7 +653,6 @@ int AtomVecSpin::unpack_exchange(double *buf)
mask[nlocal] = (int) ubuf(buf[m++]).i;
image[nlocal] = (imageint) ubuf(buf[m++]).i;
mumag[nlocal] = buf[m++];
sp[nlocal][0] = buf[m++];
sp[nlocal][1] = buf[m++];
sp[nlocal][2] = buf[m++];
@ -722,7 +709,6 @@ int AtomVecSpin::pack_restart(int i, double *buf)
buf[m++] = v[i][1];
buf[m++] = v[i][2];
buf[m++] = mumag[i];
buf[m++] = sp[i][0];
buf[m++] = sp[i][1];
buf[m++] = sp[i][2];
@ -761,7 +747,6 @@ int AtomVecSpin::unpack_restart(double *buf)
v[nlocal][1] = buf[m++];
v[nlocal][2] = buf[m++];
mumag[nlocal] = buf[m++];
sp[nlocal][0] = buf[m++];
sp[nlocal][1] = buf[m++];
sp[nlocal][2] = buf[m++];
@ -800,7 +785,6 @@ void AtomVecSpin::create_atom(int itype, double *coord)
v[nlocal][1] = 0.0;
v[nlocal][2] = 0.0;
mumag[nlocal] = 0.0;
sp[nlocal][0] = 0.0;
sp[nlocal][1] = 0.0;
sp[nlocal][2] = 0.0;
@ -824,18 +808,20 @@ void AtomVecSpin::data_atom(double *coord, imageint imagetmp, char **values)
if (type[nlocal] <= 0 || type[nlocal] > atom->ntypes)
error->one(FLERR,"Invalid atom type in Atoms section of data file");
mumag[nlocal] = atof(values[2]);
x[nlocal][0] = coord[0];
x[nlocal][1] = coord[1];
x[nlocal][2] = coord[2];
sp[nlocal][0] = atof(values[6]);
sp[nlocal][1] = atof(values[7]);
sp[nlocal][2] = atof(values[8]);
sp[nlocal][3] = sqrt(sp[nlocal][0]*sp[nlocal][0] +
sp[nlocal][3] = atof(values[2]);
sp[nlocal][0] = atof(values[5]);
sp[nlocal][1] = atof(values[6]);
sp[nlocal][2] = atof(values[7]);
double inorm = 1.0/sqrt(sp[nlocal][0]*sp[nlocal][0] +
sp[nlocal][1]*sp[nlocal][1] +
sp[nlocal][2]*sp[nlocal][2]);
sp[nlocal][0] *= inorm;
sp[nlocal][1] *= inorm;
sp[nlocal][2] *= inorm;
image[nlocal] = imagetmp;
@ -854,13 +840,17 @@ void AtomVecSpin::data_atom(double *coord, imageint imagetmp, char **values)
int AtomVecSpin::data_atom_hybrid(int nlocal, char **values)
{
mumag[nlocal] = atof(values[0]);
sp[nlocal][0] = atof(values[1]);
sp[nlocal][1] = atof(values[2]);
sp[nlocal][2] = atof(values[3]);
sp[nlocal][3] = sqrt(sp[nlocal][0]*sp[nlocal][0] +
sp[nlocal][0] = atof(values[0]);
sp[nlocal][1] = atof(values[1]);
sp[nlocal][2] = atof(values[2]);
double inorm = 1.0/sqrt(sp[nlocal][0]*sp[nlocal][0] +
sp[nlocal][1]*sp[nlocal][1] +
sp[nlocal][2]*sp[nlocal][2]);
sp[nlocal][0] *= inorm;
sp[nlocal][1] *= inorm;
sp[nlocal][2] *= inorm;
sp[nlocal][3] = atof(values[3]);
return 4;
}
@ -875,17 +865,16 @@ void AtomVecSpin::pack_data(double **buf)
for (int i = 0; i < nlocal; i++) {
buf[i][0] = ubuf(tag[i]).d;
buf[i][1] = ubuf(type[i]).d;
buf[i][2] = mumag[i];
buf[i][2] = sp[i][3];
buf[i][3] = x[i][0];
buf[i][4] = x[i][1];
buf[i][5] = x[i][2];
buf[i][6] = sp[i][0];
buf[i][7] = sp[i][1];
buf[i][8] = sp[i][2];
buf[i][9] = sp[i][3];
buf[i][10] = ubuf((image[i] & IMGMASK) - IMGMAX).d;
buf[i][11] = ubuf((image[i] >> IMGBITS & IMGMASK) - IMGMAX).d;
buf[i][12] = ubuf((image[i] >> IMG2BITS) - IMGMAX).d;
buf[i][9] = ubuf((image[i] & IMGMASK) - IMGMAX).d;
buf[i][10] = ubuf((image[i] >> IMGBITS & IMGMASK) - IMGMAX).d;
buf[i][11] = ubuf((image[i] >> IMG2BITS) - IMGMAX).d;
}
}
@ -895,13 +884,13 @@ void AtomVecSpin::pack_data(double **buf)
int AtomVecSpin::pack_data_hybrid(int i, double *buf)
{
buf[0] = mumag[i];
buf[1] = sp[i][0];
buf[2] = sp[i][1];
buf[3] = sp[i][2];
buf[4] = sp[i][3];
return 5;
buf[0] = sp[i][0];
buf[1] = sp[i][1];
buf[2] = sp[i][2];
buf[3] = sp[i][3];
return 4;
}
/* ----------------------------------------------------------------------
@ -947,7 +936,6 @@ bigint AtomVecSpin::memory_usage()
if (atom->memcheck("v")) bytes += memory->usage(v,nmax,3);
if (atom->memcheck("f")) bytes += memory->usage(f,nmax*comm->nthreads,3);
if (atom->memcheck("mumag")) bytes += memory->usage(mumag,nmax);
if (atom->memcheck("sp")) bytes += memory->usage(sp,nmax,4);
if (atom->memcheck("fm")) bytes += memory->usage(fm,nmax*comm->nthreads,3);

4
src/SPIN/atom_vec_spin.h
View File

@ -68,7 +68,9 @@ class AtomVecSpin : public AtomVec {
int *type,*mask;
imageint *image;
double **x,**v,**f; // lattice quantities
double *mumag,**sp,**fm; // spin quantities
double **sp,**fm; // spin quantities
// sp[i][0-2] direction of the spin i
// sp[i][3] atomic magnetic moment of the spin i
};

5
src/SPIN/compute_spin.cpp
View File

@ -91,7 +91,6 @@ void ComputeSpin::compute_vector()
int *mask = atom->mask;
int *type = atom->type;
imageint *image = atom->image;
double *mumag = atom->mumag;
double **sp = atom->sp;
double **fm = atom->fm;
double tx,ty,tz;
@ -103,7 +102,7 @@ void ComputeSpin::compute_vector()
for (i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) {
if (atom->mumag_flag && atom->sp_flag) {
if (atom->sp_flag) {
mag[0] += sp[i][0];
mag[1] += sp[i][1];
mag[2] += sp[i][2];
@ -116,7 +115,7 @@ void ComputeSpin::compute_vector()
countsp++;
}
}
else error->all(FLERR,"Compute spin/compute declared magnetic quantities (sp and mumag flags)");
else error->all(FLERR,"Compute compute/spin requires atom/spin style");
}
MPI_Allreduce(mag,magtot,4,MPI_DOUBLE,MPI_SUM,world);

4
src/SPIN/fix_langevin_spin.cpp
View File

@ -116,10 +116,10 @@ void FixLangevinSpin::init()
int flag_force = 0;
int flag_lang = 0;
for (int i = 0; i < modify->nfix; i++) {
if (strcmp("force/spin",modify->fix[i]->style)==0) flag_force = MAX(flag_force,i);
if (strcmp("precession/spin",modify->fix[i]->style)==0) flag_force = MAX(flag_force,i);
if (strcmp("langevin/spin",modify->fix[i]->style)==0) flag_lang = i;
}
if (flag_force >= flag_lang) error->all(FLERR,"Fix langevin/spin should come after all other spin fixes");
if (flag_force >= flag_lang) error->all(FLERR,"Fix langevin/spin has to come after all other spin fixes");
memory->create(spi,3,"langevin:spi");
memory->create(fmi,3,"langevin:fmi");

1
src/SPIN/fix_langevin_spin.h
View File

@ -31,7 +31,6 @@ class FixLangevinSpin : public Fix {
int setmask();
void init();
void setup(int);
// virtual void post_force(int);
void post_force_respa(int, int, int);
void add_tdamping(double spi[3], double fmi[3]); // add transverse damping
void add_temperature(double fmi[3]); // add temperature

175
src/SPIN/fix_integration_spin.cpp → src/SPIN/fix_nve_spin.cpp
View File

@ -23,8 +23,8 @@
#include "atom.h"
#include "atom_vec.h"
#include "error.h"
#include "fix_force_spin.h"
#include "fix_integration_spin.h"
#include "fix_precession_spin.h"
#include "fix_nve_spin.h"
#include "fix_langevin_spin.h"
#include "force.h"
#include "math_vector.h"
@ -48,63 +48,69 @@ using namespace FixConst;
using namespace MathConst;
using namespace MathExtra;
enum{NONE,SPIN};
enum{NONE};
/* ---------------------------------------------------------------------- */
FixIntegrationSpin::FixIntegrationSpin(LAMMPS *lmp, int narg, char **arg) :
FixNVESpin::FixNVESpin(LAMMPS *lmp, int narg, char **arg) :
Fix(lmp, narg, arg),
rsec(NULL), stack_head(NULL), stack_foot(NULL),
backward_stacks(NULL), forward_stacks(NULL),
lockpairspinexchange(NULL), lockpairspinsocneel(NULL), lockforcespin(NULL),
lockpairspinexchange(NULL), lockpairspinsocneel(NULL), lockprecessionspin(NULL),
locklangevinspin(NULL)
{
if (narg < 4) error->all(FLERR,"Illegal fix/integration/spin command");
if (narg < 4) error->all(FLERR,"Illegal fix/NVE/spin command");
time_integrate = 1;
extra = NONE;
mpi_flag = NONE;
sector_flag = NONE;
mech_flag = 1;
if (strcmp(arg[2],"integration/spin") == 0) {
extra = SPIN;
} else error->all(FLERR,"Illegal fix integration/spin command");
// checking if map array or hash is defined
// defining mpi_flag
if (atom->map_style == 0)
error->all(FLERR,"Fix NVE/spin requires an atom map, see atom_modify");
// defining sector_flag
int nprocs_tmp = comm->nprocs;
if (nprocs_tmp == 1) {
mpi_flag = 0;
sector_flag = 0;
} else if (nprocs_tmp >= 1) {
mpi_flag = 1;
} else error->all(FLERR,"Illegal fix/integration/spin command");
sector_flag = 1;
} else error->all(FLERR,"Illegal fix/NVE/spin command");
// defining mech_flag
int iarg = 3;
while (iarg < narg) {
if (strcmp(arg[iarg],"lattice") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal fix/integration/spin command");
if (iarg+2 > narg) error->all(FLERR,"Illegal fix/NVE/spin command");
if (strcmp(arg[iarg+1],"no") == 0) mech_flag = 0;
else if (strcmp(arg[iarg+1],"yes") == 0) mech_flag = 1;
else error->all(FLERR,"Illegal fix/integration/spin command");
else error->all(FLERR,"Illegal fix/NVE/spin command");
iarg += 2;
} else error->all(FLERR,"Illegal fix/integration/spin command");
} else error->all(FLERR,"Illegal fix/NVE/spin command");
}
if (extra == SPIN && !atom->mumag_flag)
error->all(FLERR,"Fix integration/spin requires spin attribute mumag");
// check if the atom/spin style is defined
if (mpi_flag == 0 && nprocs_tmp > 1)
error->all(FLERR,"Illegal fix/integration/spin command");
if (!atom->sp_flag)
error->all(FLERR,"Fix NVE/spin requires atom/spin style");
// check if sector_flag is correctly defined
if (sector_flag == 0 && nprocs_tmp > 1)
error->all(FLERR,"Illegal fix/NVE/spin command");
// initialize the magnetic interaction flags
magpair_flag = 0;
exch_flag = 0;
soc_neel_flag = soc_dmi_flag = 0;
me_flag = 0;
magforce_flag = 0;
magprecession_flag = 0;
zeeman_flag = aniso_flag = 0;
maglangevin_flag = 0;
tdamp_flag = temp_flag = 0;
@ -113,7 +119,7 @@ FixIntegrationSpin::FixIntegrationSpin(LAMMPS *lmp, int narg, char **arg) :
/* ---------------------------------------------------------------------- */
FixIntegrationSpin::~FixIntegrationSpin()
FixNVESpin::~FixNVESpin()
{
memory->destroy(rsec);
memory->destroy(stack_head);
@ -124,7 +130,7 @@ FixIntegrationSpin::~FixIntegrationSpin()
/* ---------------------------------------------------------------------- */
int FixIntegrationSpin::setmask()
int FixNVESpin::setmask()
{
int mask = 0;
mask |= INITIAL_INTEGRATE;
@ -135,7 +141,7 @@ int FixIntegrationSpin::setmask()
/* ---------------------------------------------------------------------- */
void FixIntegrationSpin::init()
void FixNVESpin::init()
{
// set timesteps
@ -177,15 +183,15 @@ void FixIntegrationSpin::init()
lockpairspinme = (PairSpinMe *) lockhybrid->styles[ipair];
}
}
} else error->all(FLERR,"Illegal fix integration/spin command");
} else error->all(FLERR,"Illegal fix NVE/spin command");
// check errors, and handle simple hybrid (not overlay), and no pair/spin interaction
int iforce;
for (iforce = 0; iforce < modify->nfix; iforce++) {
if (strstr(modify->fix[iforce]->style,"force/spin")) {
magforce_flag = 1;
lockforcespin = (FixForceSpin *) modify->fix[iforce];
if (strstr(modify->fix[iforce]->style,"precession/spin")) {
magprecession_flag = 1;
lockprecessionspin = (FixPrecessionSpin *) modify->fix[iforce];
}
}
@ -196,9 +202,9 @@ void FixIntegrationSpin::init()
}
}
if (magforce_flag) {
if (lockforcespin->zeeman_flag == 1) zeeman_flag = 1;
if (lockforcespin->aniso_flag == 1) aniso_flag = 1;
if (magprecession_flag) {
if (lockprecessionspin->zeeman_flag == 1) zeeman_flag = 1;
if (lockprecessionspin->aniso_flag == 1) aniso_flag = 1;
}
if (maglangevin_flag) {
@ -207,24 +213,24 @@ void FixIntegrationSpin::init()
}
nsectors = 0;
memory->create(rsec,3,"integration/spin:rsec");
memory->create(rsec,3,"NVE/spin:rsec");
// perform the sectoring if mpi integration
// perform the sectoring operation
if (mpi_flag) sectoring();
if (sector_flag) sectoring();
// grow tables of stacking variables (mpi)
// init. size tables of stacking variables (sectoring)
stack_head = memory->grow(stack_head,nsectors,"integration/spin:stack_head");
stack_foot = memory->grow(stack_foot,nsectors,"integration/spin:stack_foot");
forward_stacks = memory->grow(forward_stacks,atom->nmax,"integration/spin:forward_stacks");
backward_stacks = memory->grow(backward_stacks,atom->nmax,"integration/spin:backward_stacks");
stack_head = memory->grow(stack_head,nsectors,"NVE/spin:stack_head");
stack_foot = memory->grow(stack_foot,nsectors,"NVE/spin:stack_foot");
forward_stacks = memory->grow(forward_stacks,atom->nmax,"NVE/spin:forward_stacks");
backward_stacks = memory->grow(backward_stacks,atom->nmax,"NVE/spin:backward_stacks");
}
/* ---------------------------------------------------------------------- */
void FixIntegrationSpin::initial_integrate(int vflag)
void FixNVESpin::initial_integrate(int vflag)
{
double dtfm,msq,scale,fm2,fmsq,sp2,spsq,energy;
double spi[3], fmi[3];
@ -257,14 +263,13 @@ void FixIntegrationSpin::initial_integrate(int vflag)
// update half s for all atoms
if (extra == SPIN) {
if (mpi_flag) { // mpi seq. update
if (sector_flag) { // sectoring seq. update
for (int j = 0; j < nsectors; j++) { // advance quarter s for nlocal
comm->forward_comm();
int i = stack_foot[j];
while (i >= 0) {
ComputeInteractionsSpin(i);
AdvanceSingleSpin(i,dts);
AdvanceSingleSpin(i);
i = forward_stacks[i];
}
}
@ -273,24 +278,21 @@ void FixIntegrationSpin::initial_integrate(int vflag)
int i = stack_head[j];
while (i >= 0) {
ComputeInteractionsSpin(i);
AdvanceSingleSpin(i,dts);
AdvanceSingleSpin(i);
i = backward_stacks[i];
}
}
} else if (mpi_flag == 0) { // serial seq. update
} else if (sector_flag == 0) { // serial seq. update
comm->forward_comm(); // comm. positions of ghost atoms
for (int i = 0; i < nlocal-1; i++){ // advance quarter s for nlocal-1
for (int i = 0; i < nlocal; i++){ // advance quarter s for nlocal
ComputeInteractionsSpin(i);
AdvanceSingleSpin(i,dts);
AdvanceSingleSpin(i);
}
ComputeInteractionsSpin(nlocal-1);
AdvanceSingleSpin(nlocal-1,2.0*dts); // advance half s for 1
for (int i = nlocal-2; i >= 0; i--){ // advance quarter s for nlocal-1
for (int i = nlocal-1; i >= 0; i--){ // advance quarter s for nlocal
ComputeInteractionsSpin(i);
AdvanceSingleSpin(i,dts);
}
} else error->all(FLERR,"Illegal fix integration/spin command");
AdvanceSingleSpin(i);
}
} else error->all(FLERR,"Illegal fix NVE/spin command");
// update x for all particles
@ -306,14 +308,13 @@ void FixIntegrationSpin::initial_integrate(int vflag)
// update half s for all particles
if (extra == SPIN) {
if (mpi_flag) { // mpi seq. update
if (sector_flag) { // sectoring seq. update
for (int j = 0; j < nsectors; j++) { // advance quarter s for nlocal
comm->forward_comm();
int i = stack_foot[j];
while (i >= 0) {
ComputeInteractionsSpin(i);
AdvanceSingleSpin(i,dts);
AdvanceSingleSpin(i);
i = forward_stacks[i];
}
}
@ -322,24 +323,21 @@ void FixIntegrationSpin::initial_integrate(int vflag)
int i = stack_head[j];
while (i >= 0) {
ComputeInteractionsSpin(i);
AdvanceSingleSpin(i,dts);
AdvanceSingleSpin(i);
i = backward_stacks[i];
}
}
} else if (mpi_flag == 0) { // serial seq. update
} else if (sector_flag == 0) { // serial seq. update
comm->forward_comm(); // comm. positions of ghost atoms
for (int i = 0; i < nlocal-1; i++){ // advance quarter s for nlocal-1
for (int i = 0; i < nlocal; i++){ // advance quarter s for nlocal-1
ComputeInteractionsSpin(i);
AdvanceSingleSpin(i,dts);
AdvanceSingleSpin(i);
}
ComputeInteractionsSpin(nlocal-1);
AdvanceSingleSpin(nlocal-1,2.0*dts); // advance half s for 1
for (int i = nlocal-2; i >= 0; i--){ // advance quarter s for nlocal-1
ComputeInteractionsSpin(i);
AdvanceSingleSpin(i,dts);
}
} else error->all(FLERR,"Illegal fix integration/spin command");
AdvanceSingleSpin(i);
}
} else error->all(FLERR,"Illegal fix NVE/spin command");
}
@ -347,16 +345,16 @@ void FixIntegrationSpin::initial_integrate(int vflag)
setup pre_neighbor()
---------------------------------------------------------------------- */
void FixIntegrationSpin::setup_pre_neighbor()
void FixNVESpin::setup_pre_neighbor()
{
pre_neighbor();
}
/* ----------------------------------------------------------------------
store in two linked lists the advance order of the spins (mpi)
store in two linked lists the advance order of the spins (sectoring)
---------------------------------------------------------------------- */
void FixIntegrationSpin::pre_neighbor()
void FixNVESpin::pre_neighbor()
{
double **x = atom->x;
int nlocal = atom->nlocal;
@ -387,10 +385,10 @@ void FixIntegrationSpin::pre_neighbor()
}
/* ----------------------------------------------------------------------
compute the magnetic force for the spin ii
compute the magnetic torque for the spin ii
---------------------------------------------------------------------- */
void FixIntegrationSpin::ComputeInteractionsSpin(int ii)
void FixNVESpin::ComputeInteractionsSpin(int ii)
{
const int nlocal = atom->nlocal;
double xi[3], rij[3], eij[3];
@ -480,9 +478,6 @@ void FixIntegrationSpin::ComputeInteractionsSpin(int ii)
temp_cut = lockpairspinsocdmi->cut_soc_dmi[itype][jtype];
cut_2 = temp_cut*temp_cut;
if (rsq <= cut_2) {
eij[0] = rij[0]*inorm;
eij[1] = rij[1]*inorm;
eij[2] = rij[2]*inorm;
lockpairspinsocdmi->compute_soc_dmi(i,j,fmi,spi,spj);
}
}
@ -500,12 +495,12 @@ void FixIntegrationSpin::ComputeInteractionsSpin(int ii)
}
if (magforce_flag) { // mag. forces
if (magprecession_flag) { // magnetic precession
if (zeeman_flag) { // zeeman
lockforcespin->compute_zeeman(i,fmi);
lockprecessionspin->compute_zeeman(i,fmi);
}
if (aniso_flag) { // aniso
lockforcespin->compute_anisotropy(i,spi,fmi);
lockprecessionspin->compute_anisotropy(i,spi,fmi);
}
}
@ -530,7 +525,7 @@ void FixIntegrationSpin::ComputeInteractionsSpin(int ii)
divide each domain into sectors
---------------------------------------------------------------------- */
void FixIntegrationSpin::sectoring()
void FixNVESpin::sectoring()
{
int sec[3];
double sublo[3],subhi[3];
@ -560,7 +555,7 @@ void FixIntegrationSpin::sectoring()
nsectors = sec[0]*sec[1]*sec[2];
if (mpi_flag == 1 && nsectors != 8)
if (sector_flag == 1 && nsectors != 8)
error->all(FLERR,"Illegal sectoring operation");
rsec[0] = rsx;
@ -576,7 +571,7 @@ void FixIntegrationSpin::sectoring()
define sector for an atom at a position x[i]
---------------------------------------------------------------------- */
int FixIntegrationSpin::coords2sector(double *x)
int FixNVESpin::coords2sector(double *x)
{
int nseci;
int seci[3];
@ -596,10 +591,10 @@ int FixIntegrationSpin::coords2sector(double *x)
}
/* ----------------------------------------------------------------------
advance the spin i of a timestep dtl
advance the spin i of a timestep dts
---------------------------------------------------------------------- */
void FixIntegrationSpin::AdvanceSingleSpin(int i, double dtl)
void FixNVESpin::AdvanceSingleSpin(int i)
{
int j=0;
int *sametag = atom->sametag;
@ -613,15 +608,15 @@ void FixIntegrationSpin::AdvanceSingleSpin(int i, double dtl)
fm2 = (fm[i][0]*fm[i][0])+(fm[i][1]*fm[i][1])+(fm[i][2]*fm[i][2]);
fmsq = sqrt(fm2);
energy = (sp[i][0]*fm[i][0])+(sp[i][1]*fm[i][1])+(sp[i][2]*fm[i][2]);
dts2 = dtl*dtl;
dts2 = dts*dts;
cp[0] = fm[i][1]*sp[i][2]-fm[i][2]*sp[i][1];
cp[1] = fm[i][2]*sp[i][0]-fm[i][0]*sp[i][2];
cp[2] = fm[i][0]*sp[i][1]-fm[i][1]*sp[i][0];
g[0] = sp[i][0]+cp[0]*dtl;
g[1] = sp[i][1]+cp[1]*dtl;
g[2] = sp[i][2]+cp[2]*dtl;
g[0] = sp[i][0]+cp[0]*dts;
g[1] = sp[i][1]+cp[1]*dts;
g[2] = sp[i][2]+cp[2]*dts;
g[0] += (fm[i][0]*energy-0.5*sp[i][0]*fm2)*0.5*dts2;
g[1] += (fm[i][1]*energy-0.5*sp[i][1]*fm2)*0.5*dts2;
@ -645,7 +640,7 @@ void FixIntegrationSpin::AdvanceSingleSpin(int i, double dtl)
// comm. sp[i] to atoms with same tag (for serial algo)
if (mpi_flag == 0) {
if (sector_flag == 0) {
if (sametag[i] >= 0) {
j = sametag[i];
while (j >= 0) {
@ -661,7 +656,7 @@ void FixIntegrationSpin::AdvanceSingleSpin(int i, double dtl)
/* ---------------------------------------------------------------------- */
void FixIntegrationSpin::final_integrate()
void FixNVESpin::final_integrate()
{
double dtfm,msq,scale,fm2,fmsq,energy;
double cp[3],g[3];
@ -669,8 +664,6 @@ void FixIntegrationSpin::final_integrate()
double **x = atom->x;
double **v = atom->v;
double **f = atom->f;
double **sp = atom->sp;
double **fm = atom->fm;
double *rmass = atom->rmass;
double *mass = atom->mass;
int nlocal = atom->nlocal;

27
src/SPIN/fix_integration_spin.h → src/SPIN/fix_nve_spin.h
View File

@ -13,29 +13,29 @@
#ifdef FIX_CLASS
FixStyle(integration/spin,FixIntegrationSpin)
FixStyle(nve/spin,FixNVESpin)
#else
#ifndef LMP_FIX_INTEGRATION_SPIN_H
#define LMP_FIX_INTEGRATION_SPIN_H
#ifndef LMP_FIX_NVE_SPIN_H
#define LMP_FIX_NVE_SPIN_H
#include "fix.h"
namespace LAMMPS_NS {
class FixIntegrationSpin : public Fix {
class FixNVESpin : public Fix {
public:
FixIntegrationSpin(class LAMMPS *, int, char **);
virtual ~FixIntegrationSpin();
FixNVESpin(class LAMMPS *, int, char **);
virtual ~FixNVESpin();
int setmask();
void init();
virtual void initial_integrate(int);
virtual void final_integrate();
void ComputeInteractionsSpin(int); // compute and advance single spin functions
void AdvanceSingleSpin(int, double);
void AdvanceSingleSpin(int);
void sectoring(); // sectoring operation functions
int coords2sector(double *);
@ -44,9 +44,8 @@ class FixIntegrationSpin : public Fix {
void pre_neighbor();
protected:
int extra;
int mpi_flag; // mpi_flag = 0 if serial algorithm
// mpi_flag = 1 if parallel algorithm
int sector_flag; // sector_flag = 0 if serial algorithm
// sector_flag = 1 if parallel algorithm
int mech_flag; // mech_flag = 0 if spins only
// mech_flag = 1 if spin-lattice calc.
@ -56,7 +55,7 @@ class FixIntegrationSpin : public Fix {
int exch_flag;
int soc_neel_flag, soc_dmi_flag;
int me_flag;
int magforce_flag; // magnetic force flags
int magprecession_flag; // magnetic precession flags
int zeeman_flag, aniso_flag;
int maglangevin_flag; // magnetic langevin flags
int tdamp_flag, temp_flag;
@ -68,7 +67,7 @@ class FixIntegrationSpin : public Fix {
class PairSpinSocNeel *lockpairspinsocneel;
class PairSpinSocDmi *lockpairspinsocdmi;
class PairSpinMe *lockpairspinme;
class FixForceSpin *lockforcespin;
class FixPrecessionSpin *lockprecessionspin;
class FixLangevinSpin *locklangevinspin;
int nsectors; // sectoring variables
@ -90,13 +89,13 @@ class FixIntegrationSpin : public Fix {
/* ERROR/WARNING messages:
E: Illegal fix integration/spin command
E: Illegal fix NVE/spin command
Self-explanatory. Check the input script syntax and compare to the
documentation for the command. You can use -echo screen as a
command-line option when running LAMMPS to see the offending line.
E: Fix integration/spin requires spin attribute mumag
E: Pair spin requires atom attribute spin
An atom/spin style with this attribute is needed.

52
src/SPIN/fix_force_spin.cpp → src/SPIN/fix_precession_spin.cpp
View File

@ -24,7 +24,7 @@
#include "atom.h"
#include "domain.h"
#include "error.h"
#include "fix_force_spin.h"
#include "fix_precession_spin.h"
#include "force.h"
#include "input.h"
#include "math_const.h"
@ -43,12 +43,10 @@ enum{CONSTANT,EQUAL};
/* ---------------------------------------------------------------------- */
FixForceSpin::FixForceSpin(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg)
FixPrecessionSpin::FixPrecessionSpin(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg)
{
if (narg < 7) error->all(FLERR,"Illegal force/spin command");
// 7 arguments for a force/spin fix command:
// fix ID group force/spin magnitude (T or eV) style (zeeman or anisotropy) direction (3 cartesian coordinates)
if (narg < 7) error->all(FLERR,"Illegal precession/spin command");
// magnetic interactions coded for cartesian coordinates
@ -74,7 +72,7 @@ FixForceSpin::FixForceSpin(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, a
zeeman_flag = aniso_flag = 0;
if (strcmp(arg[3],"zeeman") == 0) {
if (narg != 8) error->all(FLERR,"Illegal force/spin command");
if (narg != 8) error->all(FLERR,"Illegal precession/spin command");
style = ZEEMAN;
zeeman_flag = 1;
H_field = force->numeric(FLERR,arg[4]);
@ -83,14 +81,14 @@ FixForceSpin::FixForceSpin(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, a
nhz = force->numeric(FLERR,arg[7]);
magfieldstyle = CONSTANT;
} else if (strcmp(arg[3],"anisotropy") == 0) {
if (narg != 8) error->all(FLERR,"Illegal force/spin command");
if (narg != 8) error->all(FLERR,"Illegal precession/spin command");
style = ANISOTROPY;
aniso_flag = 1;
Ka = force->numeric(FLERR,arg[4]);
nax = force->numeric(FLERR,arg[5]);
nay = force->numeric(FLERR,arg[6]);
naz = force->numeric(FLERR,arg[7]);
} else error->all(FLERR,"Illegal force/spin command");
} else error->all(FLERR,"Illegal precession/spin command");
degree2rad = MY_PI/180.0;
time_origin = update->ntimestep;
@ -101,14 +99,14 @@ FixForceSpin::FixForceSpin(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, a
/* ---------------------------------------------------------------------- */
FixForceSpin::~FixForceSpin()
FixPrecessionSpin::~FixPrecessionSpin()
{
delete [] magstr;
}
/* ---------------------------------------------------------------------- */
int FixForceSpin::setmask()
int FixPrecessionSpin::setmask()
{
int mask = 0;
mask |= POST_FORCE;
@ -120,7 +118,7 @@ int FixForceSpin::setmask()
/* ---------------------------------------------------------------------- */
void FixForceSpin::init()
void FixPrecessionSpin::init()
{
const double hbar = force->hplanck/MY_2PI; // eV/(rad.THz)
const double mub = 5.78901e-5; // in eV/T
@ -137,9 +135,9 @@ void FixForceSpin::init()
if (magstr) {
magvar = input->variable->find(magstr);
if (magvar < 0)
error->all(FLERR,"Illegal force/spin command");
error->all(FLERR,"Illegal precession/spin command");
if (!input->variable->equalstyle(magvar))
error->all(FLERR,"Illegal force/spin command");
error->all(FLERR,"Illegal precession/spin command");
}
varflag = CONSTANT;
@ -147,13 +145,13 @@ void FixForceSpin::init()
// set magnetic field components
if (varflag == CONSTANT) set_magneticforce();
if (varflag == CONSTANT) set_magneticprecession();
}
/* ---------------------------------------------------------------------- */
void FixForceSpin::setup(int vflag)
void FixPrecessionSpin::setup(int vflag)
{
if (strstr(update->integrate_style,"verlet"))
post_force(vflag);
@ -166,18 +164,17 @@ void FixForceSpin::setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixForceSpin::post_force(int vflag)
void FixPrecessionSpin::post_force(int vflag)
{
// update gravity due to variables
if (varflag != CONSTANT) {
modify->clearstep_compute();
modify->addstep_compute(update->ntimestep + 1);
set_magneticforce(); // update mag. field if time-dep.
set_magneticprecession(); // update mag. field if time-dep.
}
double **sp = atom->sp;
double *mumag = atom->mumag;
double **fm = atom->fm;
double spi[3], fmi[3];
const int nlocal = atom->nlocal;
@ -213,17 +210,17 @@ void FixForceSpin::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixForceSpin::compute_zeeman(int i, double fmi[3])
void FixPrecessionSpin::compute_zeeman(int i, double fmi[3])
{
double *mumag = atom->mumag;
fmi[0] -= mumag[i]*hx;
fmi[1] -= mumag[i]*hy;
fmi[2] -= mumag[i]*hz;
double **sp = atom->sp;
fmi[0] -= sp[i][3]*hx;
fmi[1] -= sp[i][3]*hy;
fmi[2] -= sp[i][3]*hz;
}
/* ---------------------------------------------------------------------- */
void FixForceSpin::compute_anisotropy(int i, double spi[3], double fmi[3])
void FixPrecessionSpin::compute_anisotropy(int i, double spi[3], double fmi[3])
{
double scalar = nax*spi[0] + nay*spi[1] + naz*spi[2];
fmi[0] += scalar*Kax;
@ -233,14 +230,14 @@ void FixForceSpin::compute_anisotropy(int i, double spi[3], double fmi[3])
/* ---------------------------------------------------------------------- */
void FixForceSpin::post_force_respa(int vflag, int ilevel, int iloop)
void FixPrecessionSpin::post_force_respa(int vflag, int ilevel, int iloop)
{
if (ilevel == ilevel_respa) post_force(vflag);
}
/* ---------------------------------------------------------------------- */
void FixForceSpin::set_magneticforce()
void FixPrecessionSpin::set_magneticprecession()
{
if (style == ZEEMAN) {
hx = H_field*nhx;
@ -258,10 +255,9 @@ void FixForceSpin::set_magneticforce()
potential energy in magnetic field
------------------------------------------------------------------------- */
double FixForceSpin::compute_scalar()
double FixPrecessionSpin::compute_scalar()
{
// only sum across procs one time
//printf("test inside compute_scalar \n");
if (eflag == 0) {
MPI_Allreduce(&emag,&emag_all,1,MPI_DOUBLE,MPI_SUM,world);

21
src/SPIN/fix_force_spin.h → src/SPIN/fix_precession_spin.h
View File

@ -13,23 +13,23 @@
#ifdef FIX_CLASS
FixStyle(force/spin,FixForceSpin)
FixStyle(precession/spin,FixPrecessionSpin)
#else
#ifndef LMP_FIX_FORCE_SPIN_H
#define LMP_FIX_FORCE_SPIN_H
#ifndef LMP_FIX_PRECESSION_SPIN_H
#define LMP_FIX_PRECESSION_SPIN_H
#include "fix.h"
namespace LAMMPS_NS {
class FixForceSpin : public Fix {
class FixPrecessionSpin : public Fix {
friend class FixPour;
public:
FixForceSpin(class LAMMPS *, int, char **);
~FixForceSpin();
FixPrecessionSpin(class LAMMPS *, int, char **);
~FixPrecessionSpin();
int setmask();
void init();
void setup(int);
@ -42,7 +42,7 @@ class FixForceSpin : public Fix {
void compute_anisotropy(int, double [3], double [3]);
protected:
int style; // style of the magnetic force
int style; // style of the magnetic precession
double degree2rad;
double hbar;
@ -68,7 +68,7 @@ class FixForceSpin : public Fix {
double nax, nay, naz;
double Kax, Kay, Kaz; // temp. force variables
void set_magneticforce();
void set_magneticprecession();
};
@ -79,10 +79,13 @@ class FixForceSpin : public Fix {
/* ERROR/WARNING messages:
E: Illegal force/spin command
E: Illegal precession/spin command
Self-explanatory. Check the input script syntax and compare to the
documentation for the command. You can use -echo screen as a
command-line option when running LAMMPS to see the offending line.
precession/spin fix command has 7 arguments:
fix ID group precession/spin magnitude (T or eV) style (zeeman or anisotropy)
direction (3 cartesian coordinates)
*/

5
src/SPIN/pair_spin_exchange.cpp
View File

@ -87,7 +87,6 @@ void PairSpinExchange::compute(int eflag, int vflag)
double **x = atom->x;
double **f = atom->f;
double **fm = atom->fm;
double *mumag = atom->mumag;
double **sp = atom->sp;
int *type = atom->type;
int nlocal = atom->nlocal;
@ -336,8 +335,8 @@ void PairSpinExchange::coeff(int narg, char **arg)
void PairSpinExchange::init_style()
{
if (!atom->sp_flag || !atom->mumag_flag)
error->all(FLERR,"Pair spin requires atom attributes sp, mumag");
if (!atom->sp_flag)
error->all(FLERR,"Pair spin requires atom/spin style");
neighbor->request(this,instance_me);

2
src/SPIN/pair_spin_exchange.h
View File

@ -74,7 +74,7 @@ E: Incorrect args for pair coefficients
Self-explanatory. Check the input script or data file.
E: Pair spin requires atom attributes sp, mumag
E: Pair spin requires atom attribute spin
The atom style defined does not have these attributes.

5
src/SPIN/pair_spin_me.cpp
View File

@ -92,7 +92,6 @@ void PairSpinMe::compute(int eflag, int vflag)
double **x = atom->x;
double **f = atom->f;
double **fm = atom->fm;
double *mumag = atom->mumag;
double **sp = atom->sp;
int *type = atom->type;
int nlocal = atom->nlocal;
@ -356,8 +355,8 @@ void PairSpinMe::coeff(int narg, char **arg)
void PairSpinMe::init_style()
{
if (!atom->sp_flag || !atom->mumag_flag)
error->all(FLERR,"Pair spin requires atom attributes sp, mumag");
if (!atom->sp_flag)
error->all(FLERR,"Pair spin requires atom/spin style");
neighbor->request(this,instance_me);

2
src/SPIN/pair_spin_me.h
View File

@ -77,7 +77,7 @@ E: Incorrect args for pair coefficients
Self-explanatory. Check the input script or data file.
E: Pair spin requires atom attributes sp, mumag
E: Pair spin requires atom attribute spin
The atom style defined does not have these attributes.

5
src/SPIN/pair_spin_soc_dmi.cpp
View File

@ -86,7 +86,6 @@ void PairSpinSocDmi::compute(int eflag, int vflag)
double **x = atom->x;
double **f = atom->f;
double **fm = atom->fm;
double *mumag = atom->mumag;
double **sp = atom->sp;
int *type = atom->type;
int nlocal = atom->nlocal;
@ -314,8 +313,8 @@ void PairSpinSocDmi::coeff(int narg, char **arg)
void PairSpinSocDmi::init_style()
{
if (!atom->sp_flag || !atom->mumag_flag)
error->all(FLERR,"Pair spin requires atom attributes sp, mumag");
if (!atom->sp_flag)
error->all(FLERR,"Pair spin requires atom/spin style");
neighbor->request(this,instance_me);

2
src/SPIN/pair_spin_soc_dmi.h
View File

@ -76,7 +76,7 @@ E: Incorrect args for pair coefficients
Self-explanatory. Check the input script or data file.
E: Pair spin requires atom attributes sp, mumag
E: Pair spin requires atom attribute spin
The atom style defined does not have these attributes.

5
src/SPIN/pair_spin_soc_neel.cpp
View File

@ -93,7 +93,6 @@ void PairSpinSocNeel::compute(int eflag, int vflag)
double **x = atom->x;
double **f = atom->f;
double **fm = atom->fm;
double *mumag = atom->mumag;
double **sp = atom->sp;
int *type = atom->type;
int nlocal = atom->nlocal;
@ -502,8 +501,8 @@ void PairSpinSocNeel::coeff(int narg, char **arg)
void PairSpinSocNeel::init_style()
{
if (!atom->sp_flag || !atom->mumag_flag)
error->all(FLERR,"Pair spin requires atom attributes sp, mumag");
if (!atom->sp_flag)
error->all(FLERR,"Pair spin requires atom/spin style");
neighbor->request(this,instance_me);

2
src/SPIN/pair_spin_soc_neel.h
View File

@ -81,7 +81,7 @@ E: Incorrect args for pair coefficients
Self-explanatory. Check the input script or data file.
E: Pair spin requires atom attributes sp, mumag
E: Pair spin requires atom attribute spin
The atom style defined does not have these attributes.

6
src/atom.cpp
View File

@ -100,7 +100,6 @@ Atom::Atom(LAMMPS *lmp) : Pointers(lmp)
// SPIN package
mumag = NULL;
sp = fm = NULL;
// USER-DPD
@ -175,7 +174,7 @@ Atom::Atom(LAMMPS *lmp) : Pointers(lmp)
// magnetic flags
sp_flag = mumag_flag = 0;
sp_flag = 0;
vfrac_flag = 0;
spin_flag = eradius_flag = ervel_flag = erforce_flag = ervelforce_flag = 0;
@ -278,7 +277,6 @@ Atom::~Atom()
memory->destroy(tri);
memory->destroy(body);
memory->destroy(mumag);
memory->destroy(sp);
memory->destroy(fm);
@ -436,7 +434,7 @@ void Atom::create_avec(const char *style, int narg, char **arg, int trysuffix)
// magnetic flags
sp_flag = mumag_flag = 0;
sp_flag = 0;
vfrac_flag = 0;
spin_flag = eradius_flag = ervel_flag = erforce_flag = ervelforce_flag = 0;

4
src/atom.h
View File

@ -63,7 +63,7 @@ class Atom : protected Pointers {
// SPIN package
double *mumag, **sp;
double **sp;
double **fm;
// PERI package
@ -153,7 +153,7 @@ class Atom : protected Pointers {
//USER-SPIN package
int mumag_flag,sp_flag;
int sp_flag;
// USER-SMD package

141
src/compute_property_atom.cpp
View File

@ -141,7 +141,41 @@ ComputePropertyAtom::ComputePropertyAtom(LAMMPS *lmp, int narg, char **arg) :
error->all(FLERR,"Compute property/atom for "
"atom property that isn't allocated");
pack_choice[i] = &ComputePropertyAtom::pack_mu;
} else if (strcmp(arg[iarg],"spx") == 0) { // pack magnetic variables
if (!atom->sp_flag)
error->all(FLERR,"Compute property/atom for "
"atom property that isn't allocated");
pack_choice[i] = &ComputePropertyAtom::pack_spx;
} else if (strcmp(arg[iarg],"spy") == 0) {
if (!atom->sp_flag)
error->all(FLERR,"Compute property/atom for "
"atom property that isn't allocated");
pack_choice[i] = &ComputePropertyAtom::pack_spy;
} else if (strcmp(arg[iarg],"spz") == 0) {
if (!atom->sp_flag)
error->all(FLERR,"Compute property/atom for "
"atom property that isn't allocated");
pack_choice[i] = &ComputePropertyAtom::pack_spz;
} else if (strcmp(arg[iarg],"sp") == 0) {
if (!atom->sp_flag)
error->all(FLERR,"Compute property/atom for "
"atom property that isn't allocated");
pack_choice[i] = &ComputePropertyAtom::pack_sp;
} else if (strcmp(arg[iarg],"fmx") == 0) {
if (!atom->sp_flag)
error->all(FLERR,"Compute property/atom for "
"atom property that isn't allocated");
pack_choice[i] = &ComputePropertyAtom::pack_fmx;
} else if (strcmp(arg[iarg],"fmy") == 0) {
if (!atom->sp_flag)
error->all(FLERR,"Compute property/atom for "
"atom property that isn't allocated");
pack_choice[i] = &ComputePropertyAtom::pack_fmy;
} else if (strcmp(arg[iarg],"fmz") == 0) {
if (!atom->sp_flag)
error->all(FLERR,"Compute property/atom for "
"atom property that isn't allocated");
pack_choice[i] = &ComputePropertyAtom::pack_fmz;
} else if (strcmp(arg[iarg],"radius") == 0) {
if (!atom->radius_flag)
error->all(FLERR,"Compute property/atom for "
@ -1000,6 +1034,111 @@ void ComputePropertyAtom::pack_mu(int n)
/* ---------------------------------------------------------------------- */
void ComputePropertyAtom::pack_spx(int n)
{
double **sp = atom->sp;
int *mask = atom->mask;
int nlocal = atom->nlocal;
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = sp[i][0];
else buf[n] = 0.0;
n += nvalues;
}
}
/* ---------------------------------------------------------------------- */
void ComputePropertyAtom::pack_spy(int n)
{
double **sp = atom->sp;
int *mask = atom->mask;
int nlocal = atom->nlocal;
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = sp[i][1];
else buf[n] = 0.0;
n += nvalues;
}
}
/* ---------------------------------------------------------------------- */
void ComputePropertyAtom::pack_spz(int n)
{
double **sp = atom->sp;
int *mask = atom->mask;
int nlocal = atom->nlocal;
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = sp[i][2];
else buf[n] = 0.0;
n += nvalues;
}
}
/* ---------------------------------------------------------------------- */
void ComputePropertyAtom::pack_sp(int n)
{
double **sp = atom->sp;
int *mask = atom->mask;
int nlocal = atom->nlocal;
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = sp[i][3];
else buf[n] = 0.0;
n += nvalues;
}
}
/* ---------------------------------------------------------------------- */
void ComputePropertyAtom::pack_fmx(int n)
{
double **fm = atom->fm;
int *mask = atom->mask;
int nlocal = atom->nlocal;
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = fm[i][0];
else buf[n] = 0.0;
n += nvalues;
}
}
/* ---------------------------------------------------------------------- */
void ComputePropertyAtom::pack_fmy(int n)
{
double **fm = atom->fm;
int *mask = atom->mask;
int nlocal = atom->nlocal;
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = fm[i][1];
else buf[n] = 0.0;
n += nvalues;
}
}
/* ---------------------------------------------------------------------- */
void ComputePropertyAtom::pack_fmz(int n)
{
double **fm = atom->fm;
int *mask = atom->mask;
int nlocal = atom->nlocal;
for (int i = 0; i < nlocal; i++) {
if (mask[i] & groupbit) buf[n] = fm[i][2];
else buf[n] = 0.0;
n += nvalues;
}
}
/* ---------------------------------------------------------------------- */
void ComputePropertyAtom::pack_radius(int n)
{
double *radius = atom->radius;

8
src/compute_property_atom.h
View File

@ -84,6 +84,14 @@ class ComputePropertyAtom : public Compute {
void pack_radius(int);
void pack_diameter(int);
void pack_spx(int); // pack magnetic variables
void pack_spy(int);
void pack_spz(int);
void pack_sp(int);
void pack_fmx(int);
void pack_fmy(int);
void pack_fmz(int);
void pack_omegax(int);
void pack_omegay(int);
void pack_omegaz(int);

127
src/dump_custom.cpp
View File

@ -854,36 +854,6 @@ int DumpCustom::count()
for (i = 0; i < nlocal; i++) dchoose[i] = 2.0*radius[i];
ptr = dchoose;
nstride = 1;
} else if (thresh_array[ithresh] == MUMAG) {//Magnetic properties
if (!atom->mumag_flag)
error->all(FLERR,
"Threshold for an atom property that isn't allocated");
ptr = atom->mumag;
nstride = 1;
} else if (thresh_array[ithresh] == SPX) {
if (!atom->sp_flag)
error->all(FLERR,
"Threshold for an atom property that isn't allocated");
ptr = &atom->sp[0][0];
nstride = 4;
} else if (thresh_array[ithresh] == SPY) {
if (!atom->sp_flag)
error->all(FLERR,
"Threshold for an atom property that isn't allocated");
ptr = &atom->sp[0][1];
nstride = 4;
} else if (thresh_array[ithresh] == SPZ) {
if (!atom->sp_flag)
error->all(FLERR,
"Threshold for an atom property that isn't allocated");
ptr = &atom->sp[0][2];
nstride = 4;
} else if (thresh_array[ithresh] == SP) {
if (!atom->sp_flag)
error->all(FLERR,
"Threshold for an atom property that isn't allocated");
ptr = &atom->sp[0][3];
nstride = 4;
} else if (thresh_array[ithresh] == OMEGAX) {
if (!atom->omega_flag)
error->all(FLERR,
@ -1311,36 +1281,6 @@ int DumpCustom::parse_fields(int narg, char **arg)
error->all(FLERR,"Dumping an atom property that isn't allocated");
pack_choice[i] = &DumpCustom::pack_mu;
vtype[i] = DOUBLE;
} else if (strcmp(arg[iarg],"mumag") == 0) {//Magnetic properties
if (!atom->mumag_flag)
error->all(FLERR,"Dumping an atom property that isn't allocated");
pack_choice[i] = &DumpCustom::pack_mumag;
vtype[i] = DOUBLE;
} else if (strcmp(arg[iarg],"spx") == 0) {
strcpy(arg[iarg],"vx");
if (!atom->sp_flag)
error->all(FLERR,"Dumping an atom property that isn't allocated");
pack_choice[i] = &DumpCustom::pack_spx;
vtype[i] = DOUBLE;
} else if (strcmp(arg[iarg],"spy") == 0) {
strcpy(arg[iarg],"vy");
if (!atom->sp_flag)
error->all(FLERR,"Dumping an atom property that isn't allocated");
pack_choice[i] = &DumpCustom::pack_spy;
vtype[i] = DOUBLE;
} else if (strcmp(arg[iarg],"spz") == 0) {
strcpy(arg[iarg],"vz");
if (!atom->sp_flag)
error->all(FLERR,"Dumping an atom property that isn't allocated");
pack_choice[i] = &DumpCustom::pack_spz;
vtype[i] = DOUBLE;
} else if (strcmp(arg[iarg],"sp") == 0) {
if (!atom->sp_flag)
error->all(FLERR,"Dumping an atom property that isn't allocated");
pack_choice[i] = &DumpCustom::pack_sp;
vtype[i] = DOUBLE;
} else if (strcmp(arg[iarg],"radius") == 0) {
if (!atom->radius_flag)
error->all(FLERR,"Dumping an atom property that isn't allocated");
@ -1844,13 +1784,6 @@ int DumpCustom::modify_param(int narg, char **arg)
else if (strcmp(arg[1],"muz") == 0) thresh_array[nthresh] = MUZ;
else if (strcmp(arg[1],"mu") == 0) thresh_array[nthresh] = MU;
//Magnetic quantities
else if (strcmp(arg[1],"mumag") == 0) thresh_array[nthresh] = MUMAG;
else if (strcmp(arg[1],"spx") == 0) thresh_array[nthresh] = SPX;
else if (strcmp(arg[1],"spy") == 0) thresh_array[nthresh] = SPY;
else if (strcmp(arg[1],"spz") == 0) thresh_array[nthresh] = SPZ;
else if (strcmp(arg[1],"sp") == 0) thresh_array[nthresh] = SP;
else if (strcmp(arg[1],"radius") == 0) thresh_array[nthresh] = RADIUS;
else if (strcmp(arg[1],"diameter") == 0) thresh_array[nthresh] = DIAMETER;
else if (strcmp(arg[1],"omegax") == 0) thresh_array[nthresh] = OMEGAX;
@ -2764,66 +2697,6 @@ void DumpCustom::pack_mu(int n)
}
}
/* ---------------------------------------------------------------------- */
//Magnetic quantities
void DumpCustom::pack_mumag(int n)
{
double *mumag = atom->mumag;
for (int i = 0; i < nchoose; i++) {
buf[n] = mumag[clist[i]];
n += size_one;
}
}
/* ---------------------------------------------------------------------- */
void DumpCustom::pack_spx(int n)
{
double **sp = atom->sp;
for (int i = 0; i < nchoose; i++) {
buf[n] = sp[clist[i]][0];
n += size_one;
}
}
/* ---------------------------------------------------------------------- */
void DumpCustom::pack_spy(int n)
{
double **sp = atom->sp;
for (int i = 0; i < nchoose; i++) {
buf[n] = sp[clist[i]][1];
n += size_one;
}
}
/* ---------------------------------------------------------------------- */
void DumpCustom::pack_spz(int n)
{
double **sp = atom->sp;
for (int i = 0; i < nchoose; i++) {
buf[n] = sp[clist[i]][2];
n += size_one;
}
}
/* ---------------------------------------------------------------------- */
void DumpCustom::pack_sp(int n)
{
double **sp = atom->sp;
for (int i = 0; i < nchoose; i++) {
buf[n] = sp[clist[i]][3];
n += size_one;
}
}
/* ---------------------------------------------------------------------- */
void DumpCustom::pack_radius(int n)

5
src/dump_custom.h
View File

@ -178,11 +178,6 @@ class DumpCustom : public Dump {
void pack_muy(int);
void pack_muz(int);
void pack_mu(int);
void pack_mumag(int); //Magnetic quantities
void pack_spx(int);
void pack_spy(int);
void pack_spz(int);
void pack_sp(int);
void pack_radius(int);
void pack_diameter(int);

2
src/pair_hybrid.h
View File

@ -31,7 +31,7 @@ class PairHybrid : public Pair {
friend class FixOMP;
friend class Force;
friend class Respa;
friend class FixIntegrationSpin;
friend class FixNVESpin;
friend class Info;
public:
PairHybrid(class LAMMPS *);

20
src/set.cpp
View File

@ -853,14 +853,11 @@ void Set::set(int keyword)
else if (keyword == SPIN) {
double **sp = atom->sp;
double *mumag = atom->mumag;
double sp_norm = sqrt(xvalue*xvalue+yvalue*yvalue+zvalue*zvalue);
sp[i][0] = xvalue/sp_norm;
sp[i][1] = yvalue/sp_norm;
sp[i][2] = zvalue/sp_norm;
sp[i][3] = sqrt(sp[i][0]*sp[i][0] + sp[i][1]*sp[i][1] +
sp[i][2]*sp[i][2]); //Should be 1 for atomic spins
mumag[i] = dvalue;
double inorm = 1.0/sqrt(xvalue*xvalue+yvalue*yvalue+zvalue*zvalue);
sp[i][0] = inorm*xvalue;
sp[i][1] = inorm*yvalue;
sp[i][2] = inorm*zvalue;
sp[i][3] = dvalue;
}
// set quaternion orientation of ellipsoid or tri or body particle
@ -1030,7 +1027,6 @@ void Set::setrandom(int keyword)
} else if (keyword == SPIN_RANDOM) {
double **sp = atom->sp;
double *mumag = atom->mumag;
int nlocal = atom->nlocal;
double sp_sq,scale;
@ -1047,8 +1043,7 @@ void Set::setrandom(int keyword)
sp[i][0] *= scale;
sp[i][1] *= scale;
sp[i][2] *= scale;
sp[i][3] = sqrt(sp_sq);
mumag[i] = dvalue;
sp[i][3] = dvalue;
count++;
}
@ -1063,8 +1058,7 @@ void Set::setrandom(int keyword)
scale = 1.0/sqrt(sp_sq);
sp[i][0] *= scale;
sp[i][1] *= scale;
sp[i][3] = sqrt(sp_sq);
mumag[i] = dvalue;
sp[i][3] = dvalue;
count++;
}
}

2
src/verlet.cpp
View File

@ -75,7 +75,7 @@ void Verlet::init()
torqueflag = extraflag = 0;
if (atom->torque_flag) torqueflag = 1;
if (atom->avec->forceclearflag) extraflag = 1;
if (atom->mumag_flag) extraflag = 1;
if (atom->sp_flag) extraflag = 1;
// orthogonal vs triclinic simulation box