Meson compiler test

.github/workflows/build.yml

@@ -0,0 +1,37 @@
+name: Build and Test
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Setup Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: 3.9
+
+    - name: Install system dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y libblas-dev liblapack-dev gfortran pkg-config
+
+    - name: Install Python dependencies
+      run: |
+        pip install meson ninja meson-python numpy scipy ase pytest
+
+    - name: Setup build directory
+      run: meson setup builddir
+
+    - name: Compile
+      run: meson compile -C builddir
+
+
+#    - name: Install package
+#      run: meson install -C builddir
+
+#    - name: Run tests
+#      run: meson test -C builddir

.github/workflows/pythonapp.yml

@@ -36,7 +36,8 @@ jobs:
         sudo apt-get install gfortran libblas-dev liblapack-dev
     - name: Install the package
       run: |
-        python setup.py install --user
+        # python setup.py install --user
+        pip install .
     - name: Test with pytest
       run: |
         pip install pytest

CModules/wrapper3.c

@@ -45,13 +45,15 @@ static PyObject * gram_schmidt(PyObject* self, PyObject* args) {
     int NewDim;
 
     PyObject * npy_vectors;
-    
+
     // Get the path dir
     if (!PyArg_ParseTuple(args, "Oii", &npy_vectors, &N_vectors, &N_dim))
         return NULL;
 
     // Get the C pointers to the data of the numpy ndarray
-    vectors = (double*) PyArray_DATA(npy_vectors);
+    //vectors = (double*) PyArray_DATA(npy_vectors);
+    // Fix for new version of numpy and python
+    vectors = (double*) PyArray_DATA((PyArrayObject*) npy_vectors);
 
     NewDim = GramSchmidt(vectors, N_dim, N_vectors);
 

CellConstructor Installation Guide.md

@@ -0,0 +1,126 @@
+# CellConstructor Installation Guide
+
+This guide provides step-by-step instructions to compile and install the CellConstructor library. The project uses the Meson build system to compile C and Fortran extensions for Python.
+
+## Recommended Installation: Conda / Mamba
+
+The easiest and most reproducible way to install CellConstructor is by using a Conda environment. We strongly recommend using *micromamba* or *mamba* as they are significantly faster. This method installs all the required compilers, libraries, and Python packages inside an isolated environment, avoiding the need to modify your base system.
+
+### Step 1: Create and Activate the Environment
+
+1. Install Conda/Mamba. If you don't have it, we recommend installing micromamba.
+
+2. Create the environment. Open your terminal and run the following command. It will create a new environment named sscha with all the necessary dependencies.
+
+```bash
+micromamba create -n sscha python=3.12 gfortran libblas lapack openmpi openmpi-mpicc pkg-config pip numpy scipy spglib=2.2
+```
+
+* Python Version: We use Python 3.12. Newer versions are not yet supported due to a dependency constraint from *spglib <= 2.2.*
+
+* pkg-config: This package is essential. Meson requires it to correctly detect the BLAS and LAPACK libraries provided by Conda.
+
+3. Activate the environment. You must activate the environment before proceeding.
+
+```bash
+micromamba activate sscha
+```
+
+### Step 2: Clone the Repository (if not done)
+
+If you don't have the source code locally, clone it from the repository.
+
+```bash
+git clone https://github.com/SSCHAcode/CellConstructo
+cd CellConstructor
+```
+
+### Step 3: Install CellConstructor
+
+With the environment active, install the package using *pip*. *pip* will automatically use Meson to compile and install the project.
+
+```bash
+pip install .
+```
+
+The installation is now complete! You can verify it by running the tests or importing the modules in Python.
+
+## Advanced Installation: Manual Configuration
+
+This section is for users who cannot use Conda or need to configure the build with specific compilers or options.
+
+### Prerequisites
+
+* A C and Fortran compiler.
+
+* Python 3.12 and pip.
+
+* Ninja and Meson: *pip install meson ninja*.
+
+* System libraries for BLAS, LAPACK, and MPI.
+
+### Method 1: Using Environment Variables
+
+You can specify compilers by setting the *CC* (C compiler) and *FC* (Fortran compiler) environment variables before running *pip*.
+
+```bash
+# Example using compilers from a specific toolchain
+export CC=/usr/local/bin/gcc-11
+export FC=/usr/local/bin/gfortran-11
+
+# Install the project
+pip install .
+```
+
+### Method 2: Using a Meson Cross File
+
+For a reproducible setup, define your compilers in a file (e.g., native-toolchain.ini).
+Example *native-toolchain.ini*:
+
+```bash
+[binaries]
+c = '/path/to/my/custom/gcc'
+fortran = '/path/to/my/custom/gfortran'
+```
+
+Then, install by passing this file to Meson via pip:
+
+```bash
+pip install . --config-settings=meson-args="--native-file=native-toolchain.ini"
+```
+
+### Build Options
+You can pass options to Meson to customize the build.
+
+* Create a debug build:
+
+```bash
+pip install . --config-settings=meson-args="-Dbuildtype=debug"
+```
+
+* Enable Intel MKL (requires MKL to be installed and findable by your system):
+
+```bash
+pip install . --config-settings=meson-args="-Duse_mkl=true"
+```
+
+* Combine multiple options:
+
+```bash
+pip install . --config-settings=meson-args="-Dbuildtype=debug,-Duse_mkl=true"
+```
+
+#### Reconfiguring a Build
+
+If you need to change build options, it is best to perform a clean installation.
+
+```bash
+# 1. Uninstall the package
+pip uninstall CellConstructor
+
+# 2. (Optional but recommended) Remove the build directory
+rm -rf build/
+
+# 3. Reinstall with the new options
+pip install . --config-settings=meson-args="-Dnew_option=value"
+```

README.md

@@ -29,20 +29,20 @@ To correnctly install and use the package, you need to have
 5. A fortran compiler
 6. Lapack
 
-The fortran compiler is required to compile the fortran libraries 
+The fortran compiler is required to compile the fortran libraries
 from Quantum ESPRESSO.
 
-Suggested, but not required, is the installation of ASE and spglib. 
-The presence of a valid ASE installation will enable some more features, 
-like the possibility to load structures by any ASE supported file format, 
+Suggested, but not required, is the installation of ASE and spglib.
+The presence of a valid ASE installation will enable some more features,
+like the possibility to load structures by any ASE supported file format,
 or the possibility to export the structures into a valid ASE Atoms class.
-This library is able to compute symmetries from the structure, 
-and inside the symmetry module there is a convertor to let CellConstructure 
-dealing with symmetries extracted with spglib. 
+This library is able to compute symmetries from the structure,
+and inside the symmetry module there is a convertor to let CellConstructure
+dealing with symmetries extracted with spglib.
 However, for a more carefull symmetry analisys, we suggest the use of external tools like ISOTROPY.
 This package can generate ISOTROPY input files for more advanced symmetry detection.
 
-Please, note that some fortran libraries are needed to be compiled, therefore the Python header files should be localized by the compiling process. 
+Please, note that some fortran libraries are needed to be compiled, therefore the Python header files should be localized by the compiling process.
 This requires the python distutils and developing tools to be properly installed.
 On ubuntu this can be achieved by running:
 ```bash
@@ -100,15 +100,15 @@ conda install clangxx_osx-64
 
 NOTE:
 If you want to install the package into a system python distribution, the
-installation commands should be executed as a superuser. 
-Otherwise, append the --user flag to either the setup.py or the pip installation. 
+installation commands should be executed as a superuser.
+Otherwise, append the --user flag to either the setup.py or the pip installation.
 In this way no administrator privileges is required, but the installation will be effective only for the current user.
 Note that some python distribution, like anaconda, does not need the superuser, as it has an installation path inside the HOME directory.
 
 You can install also using the intel compiler.
 In this case, you must edit the setup.py script so that:
 - remove the lapack and blas as extra library for the SCHAModules extension.
-- add a new flag: 'extra_link_args = ["-mkl"]' to the extension. 
+- add a new flag: 'extra_link_args = ["-mkl"]' to the extension.
 
 Remember to specify the intel compiler both to the compilation and for the running:
 CC="icc"
@@ -118,7 +118,7 @@ otherwise the C module will give an error when loaded reguarding some "_fast_mem
 
 ## GO!
 
-To test if the installation runned properly, run the examples reported 
+To test if the installation runned properly, run the examples reported
 in the test directory. The python code in these tests should be
 almost self explaining and introduce you to the potentiality of this library.
 
@@ -142,3 +142,84 @@ For example, if you want the html version run:
 make html
 ```
 inside the UserGuide directory. It will generate a build directory that contains the html version of the full documentation.
+
+## Installation using 'Meson'
+
+### Compiling with Meson
+
+To compile and install CellConstructor with Meson, follow these typical steps:
+
+### 1. Change to the Source Directory
+
+First, open a terminal and navigate to the root directory of the project source code. This is where the `meson.build` file is located.
+
+```bash
+cd /path/to/source/root/cellconstructor
+```
+
+
+### 2. Configure the Build Directory
+
+Create and configure a build directory by running:
+
+```bash
+meson setup builddir
+```
+
+or if you are in a conda env (the best option for a local installation):
+```bash
+meson setup builddir --prefix=$CONDA_PREFIX
+```
+
+if you want to use Intel MKL:
+```bash
+setup builddir -Duse_mkl=true
+```
+
+This command sets up a separate build directory (`builddir`) where all compiled files and build artifacts will be placed, keeping the source directory clean. After this, change into the build directory:
+
+```bash
+cd builddir
+```
+
+
+### 3. Compile the Project
+
+Once inside the build directory, compile the project using:
+
+```bash
+meson compile
+```
+
+This will compile the source code according to the configuration from the previous step.
+
+### 4. Run Tests (Optional)
+
+The project includes tests, you need to install pytest to work. You can run them with:
+
+```bash
+meson test
+```
+
+This step helps verify that the build works correctly.
+
+### 5. Install the Project (Optional)
+
+To install the compiled binaries, libraries, and other files system-wide (or to a custom location), run:
+
+
+```bash
+meson install
+```
+
+or
+
+```bash
+sudo meson install
+```
+
+You may need superuser privileges (hence `sudo`) to install to system directories.
+
+***
+
+Following these steps will help you successfully compile, test, and install SSCHA with Meson as their build system.

cellconstructor/Phonons.py

@@ -2875,7 +2875,7 @@ def InterpolateMesh(self, mesh_dim, lo_to_splitting = False):
         INTERPOLATE THE DYNAMICAL MATRIX IN A FINER Q MESH
         ==================================================
 
-        This method employs the Tensor2 interpolateion functions
+        This method employs the Tensor2 interpolation functions
         from the ForceTensor module to perform the interpolation.
 
         Parameters

cellconstructor/Spectral.py

@@ -241,10 +241,11 @@ def get_static_correction_interpolated(dyn, tensor3, T, new_supercell, k_grid):
     dynq = get_static_correction(dyn, tensor3, k_grid, q_tot, T)
 
     # Add all the new computed dynamical matrix
-    new_dyn.dynmats[0] = dynq[0, :, :]
-    for iq in range(1,len(q_tot)):
-        new_dyn.dynmats.append(dynq[iq, :, :])
+    all_dynmats = []
+    for iq in range(len(q_tot)):
+        all_dynmats.append(dynq[iq, :, :])
 
+    new_dyn.dynmats = all_dynmats
 
     # Adjust the dynamical matrix q points and the stars
     new_dyn.AdjustQStar()
@@ -3714,10 +3715,12 @@ def get_os_perturb_dynamic_correction_along_path(dyn, tensor3,
 #-------------------------------------------------------------------------------
 def get_dielectric_function(dyn, k_grid, T, e0 ,e1, de, ie, ismear
                             , sm0, sm0_id
-                            , diag_approx=False, nsm=1, static_limit=False): #skeleton function for TESTING...
+                            , diag_approx=False, nsm=1, static_limit=False): #Function for TESTING...
 #                  ( tensor3,omega,N,nu,q, d_bubble_cart, ener,  epsilon_inf,atom_a, atom_b, ne,frequency,dielectric_tensor,tensor2,effective_charges,energies,spectralf,N,Big_omega)
 
     """
+    This function computes the dielectric function.
+
     Input data:
      epsilon_inf = dielctric constant of vacuum ---> Phonon.Phonon.dielectric_tensor(3x3)
      a = atom a -> M(a) mass of atom a ---> tensor2 = CC.ForceTensor.Tensor2(dyn.structure, dyn_gemnerate_supwercell(dyn.GetSupercell()),dyn_GetSupercell()); tensor2.SetupFromPhonons(dyn); tensor2.center() ---> structure = tensor2.unitcell_structure ---> structure.get_masses_array()
@@ -3779,6 +3782,9 @@ def get_dielectric_function(dyn, k_grid, T, e0 ,e1, de, ie, ismear
     # ==========================================================================================
         #----------------------------------------------------------------
     def compute_k(k):
+            """
+            This function computes the k value.
+            """
             # phi3 in q, k, -q - k
             t1 = time.time()
             phi3=tensor3.Interpolate(k,-q-k, asr = False)