Merge 000eae7 into 6ef195c

core/src/Spirit/Geometry.cpp

@@ -3,7 +3,7 @@
 
 #include <data/State.hpp>
 #include <engine/Hamiltonian_Heisenberg.hpp>
-#include <engine/Vectormath.hpp>
+#include <engine/Indexing.hpp>
 #include <utility/Exception.hpp>
 #include <utility/Logging.hpp>
 
@@ -18,10 +18,10 @@ void Helper_System_Set_Geometry( Data::Spin_System & system, const Data::Geometr
     system.nos = nos;
 
     // Move the vector-fields to the new geometry
-    *system.spins = Engine::Vectormath::change_dimensions(
+    *system.spins = Engine::Indexing::change_dimensions(
         *system.spins, old_geometry.n_cell_atoms, old_geometry.n_cells, new_geometry.n_cell_atoms, new_geometry.n_cells,
         { 0, 0, 1 } );
-    system.effective_field = Engine::Vectormath::change_dimensions(
+    system.effective_field = Engine::Indexing::change_dimensions(
         system.effective_field, old_geometry.n_cell_atoms, old_geometry.n_cells, new_geometry.n_cell_atoms,
         new_geometry.n_cells, { 0, 0, 0 } );
 
@@ -83,7 +83,7 @@ void Helper_State_Set_Geometry(
 
     // Deal with clipboard configuration of State
     if( state.clipboard_spins )
-        *state.clipboard_spins = Engine::Vectormath::change_dimensions(
+        *state.clipboard_spins = Engine::Indexing::change_dimensions(
             *state.clipboard_spins, old_geometry.n_cell_atoms, old_geometry.n_cells, new_geometry.n_cell_atoms,
             new_geometry.n_cells, { 0, 0, 1 } );
 

core/src/data/Geometry.cpp

@@ -1,6 +1,6 @@
 #include <data/Geometry.hpp>
+#include <engine/Indexing.hpp>
 #include <engine/Neighbours.hpp>
-#include <engine/Vectormath.hpp>
 #include <utility/Exception.hpp>
 
 #include <Eigen/Core>
@@ -61,7 +61,7 @@ Geometry::Geometry(
     {
         const auto & site = pinning.sites[isite];
         std::size_t ispin = site.i
-                            + Engine::Vectormath::idx_from_translations(
+                            + Engine::Indexing::idx_from_translations(
                                 this->n_cells, this->n_cell_atoms,
                                 { site.translations[0], site.translations[1], site.translations[2] } );
 
@@ -74,7 +74,7 @@ Geometry::Geometry(
     {
         auto & defect     = defects.sites[i];
         std::size_t ispin = defects.sites[i].i
-                            + Engine::Vectormath::idx_from_translations(
+                            + Engine::Indexing::idx_from_translations(
                                 this->n_cells, this->n_cell_atoms,
                                 { defect.translations[0], defect.translations[1], defect.translations[2] } );
         this->atom_types[ispin] = defects.types[i];

core/src/engine/Hamiltonian_Heisenberg.cpp

@@ -8,16 +8,18 @@
 #include <data/Spin_System.hpp>
 #include <engine/Backend_par.hpp>
 #include <engine/Hamiltonian_Heisenberg.hpp>
+#include <engine/Indexing.hpp>
 #include <engine/Neighbours.hpp>
 #include <engine/Vectormath.hpp>
 #include <utility/Constants.hpp>
 
 using namespace Data;
 using namespace Utility;
 namespace C = Utility::Constants;
-using Engine::Vectormath::check_atom_type;
-using Engine::Vectormath::idx_from_pair;
-using Engine::Vectormath::idx_from_tupel;
+using Engine::Indexing::check_atom_type;
+using Engine::Indexing::idx_from_pair;
+using Engine::Indexing::idx_from_translations;
+using Engine::Indexing::idx_from_tupel;
 
 namespace Engine
 {
@@ -448,11 +450,11 @@ void Hamiltonian_Heisenberg::E_DDI_Cutoff( const vectorfield & spins, scalarfiel
                     for( int dc = 0; dc < geometry->n_cells[2]; ++dc )
                     {
                         std::array<int, 3> translations = { da, db, dc };
-                        int i                           = ddi_pairs[i_pair].i;
-                        int j                           = ddi_pairs[i_pair].j;
-                        int ispin                       = i
-                                    + Vectormath::idx_from_translations(
-                                        geometry->n_cells, geometry->n_cell_atoms, translations );
+
+                        int i = ddi_pairs[i_pair].i;
+                        int j = ddi_pairs[i_pair].j;
+                        int ispin
+                            = i + idx_from_translations( geometry->n_cells, geometry->n_cell_atoms, translations );
                         int jspin = idx_from_pair(
                             ispin, boundary_conditions, geometry->n_cells, geometry->n_cell_atoms, geometry->atom_types,
                             ddi_pairs[i_pair] );
@@ -526,9 +528,7 @@ void Hamiltonian_Heisenberg::E_Quadruplet( const vectorfield & spins, scalarfiel
             {
                 for( int dc = 0; dc < geometry->n_cells[2]; ++dc )
                 {
-                    int ispin = i
-                                + Vectormath::idx_from_translations(
-                                    geometry->n_cells, geometry->n_cell_atoms, { da, db, dc } );
+                    int ispin = i + idx_from_translations( geometry->n_cells, geometry->n_cell_atoms, { da, db, dc } );
                     int jspin = idx_from_pair(
                         ispin, boundary_conditions, geometry->n_cells, geometry->n_cell_atoms, geometry->atom_types,
                         { i, j, quad.d_j } );
@@ -896,11 +896,10 @@ void Hamiltonian_Heisenberg::Gradient_DDI_Cutoff( const vectorfield & spins, vec
                         scalar skalar_contrib           = mult / std::pow( ddi_magnitudes[i_pair], 3.0 );
                         std::array<int, 3> translations = { da, db, dc };
 
-                        int i     = ddi_pairs[i_pair].i;
-                        int j     = ddi_pairs[i_pair].j;
-                        int ispin = i
-                                    + Vectormath::idx_from_translations(
-                                        geometry->n_cells, geometry->n_cell_atoms, translations );
+                        int i = ddi_pairs[i_pair].i;
+                        int j = ddi_pairs[i_pair].j;
+                        int ispin
+                            = i + idx_from_translations( geometry->n_cells, geometry->n_cell_atoms, translations );
                         int jspin = idx_from_pair(
                             ispin, boundary_conditions, geometry->n_cells, geometry->n_cell_atoms, geometry->atom_types,
                             ddi_pairs[i_pair] );
@@ -1086,9 +1085,7 @@ void Hamiltonian_Heisenberg::Gradient_Quadruplet( const vectorfield & spins, vec
             {
                 for( int dc = 0; dc < geometry->n_cells[2]; ++dc )
                 {
-                    int ispin = i
-                                + Vectormath::idx_from_translations(
-                                    geometry->n_cells, geometry->n_cell_atoms, { da, db, dc } );
+                    int ispin = i + idx_from_translations( geometry->n_cells, geometry->n_cell_atoms, { da, db, dc } );
                     int jspin = idx_from_pair(
                         ispin, boundary_conditions, geometry->n_cells, geometry->n_cell_atoms, geometry->atom_types,
                         { i, j, quad.d_j } );

core/src/engine/Hamiltonian_Heisenberg.cu

@@ -4,6 +4,7 @@
 #include <engine/Backend_par.hpp>
 #include <engine/FFT.hpp>
 #include <engine/Hamiltonian_Heisenberg.hpp>
+#include <engine/Indexing.hpp>
 #include <engine/Neighbours.hpp>
 #include <engine/Vectormath.hpp>
 #include <utility/Constants.hpp>
@@ -16,11 +17,12 @@
 using namespace Data;
 using namespace Utility;
 namespace C = Utility::Constants;
-using Engine::Vectormath::check_atom_type;
-using Engine::Vectormath::cu_check_atom_type;
-using Engine::Vectormath::cu_idx_from_pair;
-using Engine::Vectormath::cu_tupel_from_idx;
-using Engine::Vectormath::idx_from_pair;
+using Engine::Indexing::check_atom_type;
+using Engine::Indexing::cu_check_atom_type;
+using Engine::Indexing::cu_idx_from_pair;
+using Engine::Indexing::cu_tupel_from_idx;
+using Engine::Indexing::idx_from_pair;
+using Engine::Indexing::idx_from_translations;
 
 namespace Engine
 {
@@ -632,9 +634,7 @@ void Hamiltonian_Heisenberg::E_Quadruplet( const vectorfield & spins, scalarfiel
             {
                 for( int dc = 0; dc < geometry->n_cells[2]; ++dc )
                 {
-                    int ispin = i
-                                + Vectormath::idx_from_translations(
-                                    geometry->n_cells, geometry->n_cell_atoms, { da, db, dc } );
+                    int ispin = i + idx_from_translations( geometry->n_cells, geometry->n_cell_atoms, { da, db, dc } );
                     int jspin = idx_from_pair(
                         ispin, boundary_conditions, geometry->n_cells, geometry->n_cell_atoms, geometry->atom_types,
                         { i, j, { d_j[0], d_j[1], d_j[2] } } );
@@ -1129,9 +1129,7 @@ void Hamiltonian_Heisenberg::Gradient_Quadruplet( const vectorfield & spins, vec
             {
                 for( int dc = 0; dc < geometry->n_cells[2]; ++dc )
                 {
-                    int ispin = i
-                                + Vectormath::idx_from_translations(
-                                    geometry->n_cells, geometry->n_cell_atoms, { da, db, dc } );
+                    int ispin = i + idx_from_translations( geometry->n_cells, geometry->n_cell_atoms, { da, db, dc } );
                     int jspin = idx_from_pair(
                         ispin, boundary_conditions, geometry->n_cells, geometry->n_cell_atoms, geometry->atom_types,
                         { i, j, { d_j[0], d_j[1], d_j[2] } } );

core/src/engine/Method_MC.cpp

@@ -1,6 +1,7 @@
 #include <Spirit/Spirit_Defines.h>
 #include <data/Spin_System.hpp>
 #include <data/Spin_System_Chain.hpp>
+#include <engine/Indexing.hpp>
 #include <engine/Method_MC.hpp>
 #include <engine/Vectormath.hpp>
 #include <io/IO.hpp>
@@ -107,7 +108,7 @@ void Method_MC::Metropolis( const vectorfield & spins_old, vectorfield & spins_n
             // Faster, but worse statistics
             ispin = idx;
 
-        if( Vectormath::check_atom_type( this->systems[0]->geometry->atom_types[ispin] ) )
+        if( Indexing::check_atom_type( this->systems[0]->geometry->atom_types[ispin] ) )
         {
             // Sample a cone
             if( this->parameters_mc->metropolis_step_cone )

core/src/engine/Vectormath.cpp

@@ -1,3 +1,4 @@
+#include <engine/Indexing.hpp>
 #include <engine/Manifoldmath.hpp>
 #include <engine/Vectormath.hpp>
 #include <utility/Constants.hpp>
@@ -705,7 +706,8 @@ void directional_gradient(
     // Loop over vectorfield
     for( unsigned int ispin = 0; ispin < vf.size(); ++ispin )
     {
-        auto translations_i = translations_from_idx( n_cells, geometry.n_cell_atoms, ispin ); // transVec of spin i
+        auto translations_i
+            = Indexing::translations_from_idx( n_cells, geometry.n_cell_atoms, ispin ); // transVec of spin i
         // int k = i%geometry.n_cell_atoms; // index within unit cell - k=0 for all cases used in the thesis
         scalar n = 0;
 
@@ -721,12 +723,12 @@ void directional_gradient(
         // Loop over neighbours of this vector to calculate contributions of finite differences to current direction
         for( unsigned int j = 0; j < neigh.size(); ++j )
         {
-            if( boundary_conditions_fulfilled(
+            if( Indexing::boundary_conditions_fulfilled(
                     geometry.n_cells, boundary_conditions, translations_i, neigh[j].translations ) )
             {
                 // Index of neighbour
-                int ineigh
-                    = idx_from_translations( n_cells, geometry.n_cell_atoms, translations_i, neigh[j].translations );
+                int ineigh = Indexing::idx_from_translations(
+                    n_cells, geometry.n_cell_atoms, translations_i, neigh[j].translations );
                 if( ineigh >= 0 )
                 {
                     auto d = geometry.positions[ineigh] - geometry.positions[ispin];
@@ -745,12 +747,12 @@ void directional_gradient(
         // Loop over neighbours of this vector to calculate finite differences
         for( unsigned int j = 0; j < neigh.size(); ++j )
         {
-            if( boundary_conditions_fulfilled(
+            if( Indexing::boundary_conditions_fulfilled(
                     geometry.n_cells, boundary_conditions, translations_i, neigh[j].translations ) )
             {
                 // Index of neighbour
-                int ineigh
-                    = idx_from_translations( n_cells, geometry.n_cell_atoms, translations_i, neigh[j].translations );
+                int ineigh = Indexing::idx_from_translations(
+                    n_cells, geometry.n_cell_atoms, translations_i, neigh[j].translations );
                 if( ineigh >= 0 )
                 {
                     auto d = geometry.positions[ineigh] - geometry.positions[ispin];