God class UnitCell.h: Remove redundant parts (#7734)

* remove parameter.h

* Remove unused G0/GT0/GGT0/invGGT0 members from UnitCell class

* Move print_cell from UnitCell member function to free function in unitcell namespace

* Move compare_atom_labels from UnitCell member function to free function in unitcell namespace

* add atom_in.h in read_pseudo.cpp

* add cell_tools class

* fix CMakeLists.txt

* Move deltaspin getters (get_target_mag/lambda/constrain) out of UnitCell into cell_tools

* Move if_atoms_can_move and if_cell_can_change out of UnitCell into cell_tools

* fix makefile

* remove useless step_ functions

* rename setup as setup_from_input

* fix cmake

* fix cmake

* refactor(cell): remove redundant UnitCell::atom_mass cache member, use atoms[it].mass directly

* remove atom label

* fix bug in json

* fix bug

* reduce a few lines from unitcell.h

---------

Co-authored-by: abacus_fixer <mohanchen@pku.eud.cn>

Author: mohanchen

source/Makefile.Objects

@@ -198,6 +198,7 @@ OBJS_CELL=atom_pseudo.o\
     klist.o\
     k_vector_utils.o\
     cell_index.o\
+    cell_tools.o\
     check_atomic_stru.o\
     update_cell.o\
     bcast_cell.o\

source/source_cell/CMakeLists.txt

@@ -22,6 +22,7 @@ add_library(
     klist.cpp
     parallel_kpoints.cpp
     cell_index.cpp
+    cell_tools.cpp
     check_atomic_stru.cpp
     update_cell.cpp
     magnetism.cpp

source/source_cell/cell_tools.cpp

@@ -0,0 +1,117 @@
+/**
+ * @file cell_tools.cpp
+ * @brief Implementation of cell tool free functions.
+ */
+#include "cell_tools.h"
+
+namespace unitcell
+{
+    std::vector<std::string> get_atomLabels(const Atom* atoms, const int ntype)
+    {
+        std::vector<std::string> atomLabels(ntype);
+        for (int it = 0; it < ntype; it++)
+        {
+            atomLabels[it] = atoms[it].label;
+        }
+        return atomLabels;
+    }
+
+    std::vector<int> get_atomCounts(const Atom* atoms, const int ntype)
+    {
+        std::vector<int> atomCounts(ntype);
+        for (int it = 0; it < ntype; it++)
+        {
+            atomCounts[it] = atoms[it].na;
+        }
+        return atomCounts;
+    }
+
+    std::vector<std::vector<int>> get_lnchiCounts(const Atom* atoms, const int ntype)
+    {
+        std::vector<std::vector<int>> lnchiCounts(ntype);
+        for (int it = 0; it < ntype; it++)
+        {
+            lnchiCounts[it].resize(atoms[it].nwl + 1);
+            for (int L = 0; L < atoms[it].nwl + 1; L++)
+            {
+                lnchiCounts[it][L] = atoms[it].l_nchi[L];
+            }
+        }
+        return lnchiCounts;
+    }
+
+    std::vector<ModuleBase::Vector3<double>> get_target_mag(const Atom* atoms,
+                                                            const int ntype,
+                                                            const int nat)
+    {
+        std::vector<ModuleBase::Vector3<double>> target_mag(nat);
+        int iat = 0;
+        for (int it = 0; it < ntype; it++)
+        {
+            for (int ia = 0; ia < atoms[it].na; ia++)
+            {
+                target_mag[iat] = atoms[it].m_loc_[ia];
+                ++iat;
+            }
+        }
+        return target_mag;
+    }
+
+    std::vector<ModuleBase::Vector3<double>> get_lambda(const Atom* atoms,
+                                                         const int ntype,
+                                                         const int nat)
+    {
+        std::vector<ModuleBase::Vector3<double>> lambda(nat);
+        int iat = 0;
+        for (int it = 0; it < ntype; it++)
+        {
+            for (int ia = 0; ia < atoms[it].na; ia++)
+            {
+                lambda[iat] = atoms[it].lambda[ia];
+                ++iat;
+            }
+        }
+        return lambda;
+    }
+
+    std::vector<ModuleBase::Vector3<int>> get_constrain(const Atom* atoms,
+                                                        const int ntype,
+                                                        const int nat)
+    {
+        std::vector<ModuleBase::Vector3<int>> constrain(nat);
+        int iat = 0;
+        for (int it = 0; it < ntype; it++)
+        {
+            for (int ia = 0; ia < atoms[it].na; ia++)
+            {
+                constrain[iat] = atoms[it].constrain[ia];
+                ++iat;
+            }
+        }
+        return constrain;
+    }
+
+    bool if_atoms_can_move(const Atom* atoms, const int ntype)
+    {
+        for (int it = 0; it < ntype; it++)
+        {
+            for (int ia = 0; ia < atoms[it].na; ia++)
+            {
+                if (atoms[it].mbl[ia].x || atoms[it].mbl[ia].y || atoms[it].mbl[ia].z)
+                {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    bool if_cell_can_change(const std::vector<int>& lat_axis_free)
+    {
+        if (lat_axis_free[0] || lat_axis_free[1] || lat_axis_free[2])
+        {
+            return true;
+        }
+        return false;
+    }
+}

source/source_cell/cell_tools.h

@@ -0,0 +1,76 @@
+/**
+ * @file cell_tools.h
+ * @brief Free function tools for extracting cell/atom information.
+ */
+#ifndef CELL_TOOLS_H
+#define CELL_TOOLS_H
+
+#include <string>
+#include <vector>
+
+#include "source_base/vector3.h"
+#include "source_cell/atom_spec.h"
+
+/**
+ * @brief Free functions for extracting atom/orbital info from Atom array.
+ */
+namespace unitcell
+{
+    /// @brief Get atom labels for each atom type.
+    /// @param atoms atom pointer [in]
+    /// @param ntype number of atom types [in]
+    /// @return vector of atom labels, one per type
+    std::vector<std::string> get_atomLabels(const Atom* atoms, const int ntype);
+
+    /// @brief Get atom counts (number of atoms) for each atom type.
+    /// @param atoms atom pointer [in]
+    /// @param ntype number of atom types [in]
+    /// @return vector of atom counts, one per type
+    std::vector<int> get_atomCounts(const Atom* atoms, const int ntype);
+
+    /// @brief Get lnchi counts (number of chi functions per L) for each atom type.
+    /// @param atoms atom pointer [in]
+    /// @param ntype number of atom types [in]
+    /// @return vector of lnchi counts, one vector per type
+    std::vector<std::vector<int>> get_lnchiCounts(const Atom* atoms, const int ntype);
+
+    /// @brief Get target magnetic moment for each atom (used by deltaspin).
+    /// @param atoms atom pointer [in]
+    /// @param ntype number of atom types [in]
+    /// @param nat total number of atoms [in]
+    /// @return vector of target magnetic moments, one per atom
+    std::vector<ModuleBase::Vector3<double>> get_target_mag(const Atom* atoms,
+                                                            const int ntype,
+                                                            const int nat);
+
+    /// @brief Get Lagrange multiplier for each atom (used by deltaspin).
+    /// @param atoms atom pointer [in]
+    /// @param ntype number of atom types [in]
+    /// @param nat total number of atoms [in]
+    /// @return vector of Lagrange multipliers, one per atom
+    std::vector<ModuleBase::Vector3<double>> get_lambda(const Atom* atoms,
+                                                         const int ntype,
+                                                         const int nat);
+
+    /// @brief Get constrain flag for each atom (used by deltaspin).
+    /// @param atoms atom pointer [in]
+    /// @param ntype number of atom types [in]
+    /// @param nat total number of atoms [in]
+    /// @return vector of constrain flags, one per atom
+    std::vector<ModuleBase::Vector3<int>> get_constrain(const Atom* atoms,
+                                                        const int ntype,
+                                                        const int nat);
+
+    /// @brief Judge if any atom can move (any mbl component is non-zero).
+    /// @param atoms atom pointer [in]
+    /// @param ntype number of atom types [in]
+    /// @return true if at least one atom is allowed to move
+    bool if_atoms_can_move(const Atom* atoms, const int ntype);
+
+    /// @brief Judge if any lattice vector can change.
+    /// @param lat_axis_free lattice-axis freedom flags (size 3) [in]
+    /// @return true if at least one lattice axis is free to change
+    bool if_cell_can_change(const std::vector<int>& lat_axis_free);
+}
+
+#endif // CELL_TOOLS_H

source/source_cell/module_neighbor/test/prepare_unitcell.h

@@ -71,14 +71,12 @@ class UcellTestPrepare
         //basic info
         this->ntype = this->elements.size();
         UnitCell* ucell = new UnitCell;
-        ucell->setup(this->latname,
+        ucell->setup_from_input(this->latname,
                 this->ntype,
                 this->lmaxmax,
                 this->init_vel,
                 this->fixed_axes);
 
-        ucell->atom_label.resize(ucell->ntype);
-        ucell->atom_mass.resize(ucell->ntype);
         ucell->pseudo_fn.resize(ucell->ntype);
         ucell->pseudo_type.resize(ucell->ntype);
         ucell->orbital_fn.resize(ucell->ntype);
@@ -87,8 +85,6 @@ class UcellTestPrepare
         ucell->magnet.ux_[2] = 0.0;
         for(int it=0;it<ucell->ntype;++it)
         {
-            ucell->atom_label[it] = this->elements[it];
-            ucell->atom_mass[it] = this->atomic_mass[it];
             ucell->pseudo_fn[it] = this->pp_files[it];
             ucell->pseudo_type[it] = this->pp_types[it];
             ucell->orbital_fn[it] = this->orb_files[it];
@@ -148,7 +144,7 @@ class UcellTestPrepare
             ucell->atoms[it].angle2.resize(ucell->atoms[it].na);
             ucell->atoms[it].m_loc_.resize(ucell->atoms[it].na);
             ucell->atoms[it].mbl.resize(ucell->atoms[it].na);
-            ucell->atoms[it].mass = ucell->atom_mass[it]; // mass set here
+            ucell->atoms[it].mass = this->atomic_mass[it];
 
             for(int ia=0; ia<ucell->atoms[it].na; ++ia)
             {

source/source_cell/module_symmetry/symm_magnetic.cpp

@@ -2,7 +2,7 @@
 using namespace ModuleSymmetry;
 
 #include "symmetry_rotation_spin.h"
-#include "source_io/module_parameter/parameter.h"
+#include "source_base/global_variable.h"
 
 #include <set>
 #include <vector>

source/source_cell/print_cell.cpp

@@ -5,6 +5,7 @@
 #include "source_base/formatter.h"
 #include "source_base/tool_title.h"
 #include "source_base/global_variable.h"
+#include "source_base/output.h"
 
 namespace unitcell
 {
@@ -98,8 +99,8 @@ namespace unitcell
         for(int it=0; it<ucell.ntype; it++)
         { 
             str += FmtCore::format("%s %8.4f %s %s\n", 
-                                    ucell.atom_label[it], 
-                                    ucell.atom_mass[it], 
+                                    ucell.atoms[it].label, 
+                                    ucell.atoms[it].mass, 
                                     ucell.pseudo_fn[it], 
                                     ucell.pseudo_type[it]); 
         }
@@ -166,4 +167,25 @@ namespace unitcell
         ofs.close();
         return;
     }
+
+    void print_cell(const UnitCell& ucell, std::ofstream& ofs)
+    {
+        ModuleBase::GlobalFunc::OUT(ofs, "print_unitcell()");
+
+        ModuleBase::GlobalFunc::OUT(ofs, "latName", ucell.latName);
+        ModuleBase::GlobalFunc::OUT(ofs, "ntype", ucell.ntype);
+        ModuleBase::GlobalFunc::OUT(ofs, "nat", ucell.nat);
+        ModuleBase::GlobalFunc::OUT(ofs, "lat0", ucell.lat0);
+        ModuleBase::GlobalFunc::OUT(ofs, "lat0_angstrom", ucell.lat0_angstrom);
+        ModuleBase::GlobalFunc::OUT(ofs, "tpiba", ucell.tpiba);
+        ModuleBase::GlobalFunc::OUT(ofs, "omega", ucell.omega);
+
+        output::printM3(ofs, "Lattices Vector (R) : ", ucell.latvec);
+        output::printM3(ofs, "Supercell lattice vector : ", ucell.latvec_supercell);
+        output::printM3(ofs, "Reciprocal lattice Vector (G): ", ucell.G);
+        output::printM3(ofs, "GGT : ", ucell.GGT);
+
+        ofs << std::endl;
+        return;
+    }
 }

source/source_cell/print_cell.h

@@ -53,6 +53,14 @@ namespace unitcell
                          const bool& orb = false,
                          const bool& dpks_desc = false,
                          const int& iproc = 0);
+
+    /**
+     * @brief Print basic unitcell information to output stream.
+     *
+     * @param ucell reference of unitcell [in]
+     * @param ofs output file stream [in]
+     */
+    void print_cell(const UnitCell& ucell, std::ofstream& ofs);
 }
 
 #endif

source/source_cell/read_atom_species.cpp

@@ -34,7 +34,7 @@ bool read_atom_species(std::ifstream& ifa,
             std::getline(ifa, one_line);
             std::stringstream ss;
             ss << one_line;
-            ss >> ucell.atom_label[i] >> ucell.atom_mass[i];
+            ss >> ucell.atoms[i].label >> ucell.atoms[i].mass;
             ucell.pseudo_fn[i] = "auto";
             ucell.pseudo_type[i] = "auto";
 
@@ -73,8 +73,8 @@ bool read_atom_species(std::ifstream& ifa,
             // Peize Lin test for bsse 2021.04.07
             const std::string bsse_label = "empty";
             ucell.atoms[i].flag_empty_element = 
-                (search( ucell.atom_label[i].begin(), ucell.atom_label[i].end(), 
-                    bsse_label.begin(), bsse_label.end() ) != ucell.atom_label[i].end())
+                (search( ucell.atoms[i].label.begin(), ucell.atoms[i].label.end(), 
+                    bsse_label.begin(), bsse_label.end() ) != ucell.atoms[i].label.end())
                 ? true : false;
         }
     }

source/source_cell/read_atoms.cpp

@@ -72,7 +72,7 @@ bool unitcell::read_atom_positions(UnitCell& ucell,
 
             if (na > 0)
             {
-                unitcell::allocate_atom_properties(ucell.atoms[it], na, ucell.atom_mass[it]);
+                unitcell::allocate_atom_properties(ucell.atoms[it], na);
                 for (int ia = 0;ia < na; ia++)
                 {
                  // modify the reading of frozen ions and velocities  -- Yuanbo Li 2021/8/20