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.12
+
+    - 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/python-testsuite.yml

@@ -51,12 +51,13 @@ jobs:
       run: |
         sudo apt-get update
         sudo apt-get install git gfortran libblas-dev liblapack-dev
-        git clone https://github.com/mesonepigreco/CellConstructor.git
+        git clone https://github.com/SSCHAcode/CellConstructor.git
+        pip install meson meson-python ninja
         cd CellConstructor
-        python setup.py install --user
+        pip install --no-build-isolation .
         cd ..
 
-        python setup.py install --user
+        pip install --no-build-isolation .
 
         # Install julia requirements
         python -c 'import julia; julia.install()'

README.md

@@ -8,11 +8,11 @@ See more info on the webpage:
 
 ## Easy installation through Anaconda
 
-The SSCHA code comes as a python library, with computationally intense part speedup with C, Fortran and Julia. The easiest way to install is through Anaconda ([how to install anaconda](https://www.anaconda.com/download)) 
+The SSCHA code comes as a python library, with computationally intense part speedup with C, Fortran and Julia. The easiest way to install is through Anaconda ([how to install anaconda](https://www.anaconda.com/download))
 
 
 ```
-conda create -n sscha -c conda-forge python=3.10 gfortran=11 libblas lapack openmpi julia openmpi-mpicc pip=23 numpy=1.26 scipy=1.10 spglib=2.2 setuptools=64
+conda create -n sscha -c conda-forge python=3.12 gfortran=11 libblas lapack openmpi julia openmpi-mpicc pip=23 numpy=1.26 scipy=1.10 spglib=2.2
 conda activate sscha
 pip install ase julia mpi4py
 pip install cellconstructor python-sscha tdscha
@@ -27,7 +27,7 @@ If you want the julia speedup, see the section on Manual installation to preconf
 
 ## Video lessons from  the 2023 School are available
 
-The full recordings, both of theoretical lectures, tutorials and Hands-on sessions can be found 
+The full recordings, both of theoretical lectures, tutorials and Hands-on sessions can be found
 in our youtube channel [SSCHAcode](https://www.youtube.com/@SSCHAcode>)
 
 This is the safest and best way to install the SSCHA. The first line creates a new pristine python environment with all the required libraries to compile the source code. The second line activates the newly installed environment. Then, the thrid command installs the additional dependencies, the last line compiles and install the SSCHA code.
@@ -47,7 +47,7 @@ python -c 'import julia; julia.install()'
 ```
 
 
-## Installing without Anaconda 
+## Installing without Anaconda
 
 If you do not have anaconda to handle your dependencies you need to manually compile the code.
 
@@ -76,7 +76,7 @@ The SSCHA code is a collection of 3 python packages: CellConstructor, python-ssc
 
 - [CellConstructor](https://github.com/SSCHAcode/CellConstructor>): utility to manage phonon dispersions, atomic structures and crystal symmetries
 - [sscha](https://github.com/SSCHAcode/python-sscha>) : This repository, relax with anharmonicity and compute static linear response properties.
-- [tdscha](<https://github.com/SSCHAcode/tdscha>) : Compute the dynamical linear response (Raman and IR, spectral functions) 
+- [tdscha](<https://github.com/SSCHAcode/tdscha>) : Compute the dynamical linear response (Raman and IR, spectral functions)
 
 More details about installations are in the official website [www.sscha.eu](https://sscha.eu/download>)
 
@@ -89,7 +89,7 @@ First make sure you have anaconda installed [(install anaconda)](https://www.ana
 The following commands are sufficient to install the full sscha suite and its dependencies.
 
 ```
-conda create -n sscha -c conda-forge python=3.10 gfortran=11 libblas lapack openmpi julia openmpi-mpicc pip=23 numpy=1.26 scipy=1.10 spglib=2.2 setuptools=64
+conda create -n sscha -c conda-forge python=3.12 gfortran=11 libblas lapack openmpi julia openmpi-mpicc pip=23 numpy=1.26 scipy=1.10 spglib=2.2
 conda activate sscha
 pip install ase julia mpi4py
 pip install cellconstructor python-sscha tdscha
@@ -175,3 +175,80 @@ For example
 
 For the development version of the code, subtitute the pip call with the python setup.py install.
 
+## Compiling with Meson
+
+To compile and install SSCHA 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/python-sscha
+```
+
+
+### 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.

UserGuide/install.rst

@@ -68,15 +68,15 @@ For python, we strongly recommend using the anaconda distribution, that already
 
 The numpy, scipy and matplotlib are python packages. These are usually provided with a new installation
 of python distributions like anaconda. Lapack and Blas are needed for compiling the FORTRAN code (together with a FORTRAN compiler like gfortran).
-In many Linux distributions like ubuntu they can be installed as 
+In many Linux distributions like ubuntu they can be installed as
 
 .. code-block:: console
 
    sudo apt-get install libblas-dev liblapack-dev liblapacke-dev gfortran
 
 
 
-Note that this specific command may change in time. 
+Note that this specific command may change in time.
 
 
 Together with these mandatory requirements (otherwise, the code will not compile correctly or raise an exception at the startup), we
@@ -90,7 +90,7 @@ If these packages are available, they will enable the automatic cluster/local ca
 To install all the python dependencies (and recommended) automatically, you may just run:
 
 .. code-block:: console
-   
+
    pip install -r requirements.txt
 
 
@@ -102,8 +102,8 @@ Installation from pip
 The easiest way to install python-sscha (and CellConstructor) is through the python package manager:
 
 .. code-block:: console
-   
-   pip install python-sscha 
+
+   pip install python-sscha
 
 
 
@@ -116,43 +116,121 @@ Installation from source
 ------------------------
 
 Once all the dependences of the codes are satisfied, you can unzip the source code downloaded from the website.
-Then run, inside the directory that contains the setup.py script, the following command:
+Then run, inside the directory that contains the meson.build script, the following command:
 
 .. code-block:: console
 
-   python setup.py install
+   pip install .
 
 
 As for the pip installation, you may append the --user option to install the package only for the user (without requiring administrator powers).
 
+An "editable" install is highly recommended for developers. It allows you to modify the source code and have the changes reflected immediately without needing to reinstall.
+.. code-block:: console
+
+   pip install -e .
+
 
 Install with Intel FORTRAN compiler
 -----------------------------------
 
-The setup.py script works automatically with the GNU FORTRAN compiler. However, due to some differences in linking lapack,
-to use the intel compiler you need to edit a bit the setup.py script:
+Meson works automatically with several FORTRAN compilers, including Intel FORTRAN. However, due to some differences in linking lapack,
+to use the intel compiler you need to:
+
+Ensure MKL is installed in your Conda environment:
+.. code-block:: console
+
+   conda install mkl mkl-devel
+
+You can pass Meson options through pip's \--config-settings flag.
+.. code-block:: console
+
+    pip install . --config-settings=--setup-args=-Duse_mkl=true
 
-In this case, you need to delete the lapack linking from the
-setup.py and include the -mkl as linker option.
-Note that you must force to use the same liker compiler as the one used for the compilation. 
+Or for an editable install:
+.. code-block:: console
+    pip install -e . --config-settings=--setup-args=-Duse_mkl=true
 
 Install with a specific compiler path
 -------------------------------------
 
-This can be achieved by specifying the environment variables on which setup.py relies:
+Method 1: Using Environment Variables (Recommended for most cases)
+------------------------------------------------------------------
+
+Meson automatically detects compilers using standard environment variables. You can set these variables before running the installation command. This is the simplest way to specify a compiler for a single build.
+
+The key variables are:
+
+    CC: Specifies the C compiler executable.
 
-1. CC (C compiler)
-2. FC (Fortran compiler)
-3. LDSHARED (linking)
+    CXX: Specifies the C++ compiler executable.
 
-If we want to use a custom compiler in /path/to/fcompiler we may run the setup as:
+    FC: Specifies the Fortran compiler executable.
+
+Step-by-Step Instructions
+
+1. Open your terminal. All commands must be run in the same session, as environment variables are typically not permanent.
+2. Set the environment variables to point to your desired compilers.
+
+Example for C (using a specific gcc):
 
 .. code-block:: console
+    export CC=/path/to/my/custom/gcc
 
-   FC=/path/to/fcompiler LDSHARED=/path/to/fcompiler python setup.py install
+Example for Fortran (using a specific gfortran):
 
+.. code-block:: console
+    export FC=/path/to/my/custom/gfortran
 
+Example for C++ (if the project needed it):
 
-A specific setup.py script is provided to install it easily in FOSS clusters.
+.. code-block:: console
+    export CXX=/path/to/my/custom/g++
 
+3. Combine them as needed. For this project, you will likely need to set CC and FC.
+
+# Example using compilers from a specific toolchain
+.. code-block:: console
+    export CC=/usr/local/bin/gcc-11
+    export FC=/usr/local/bin/gfortran-11
+
+4. Run the pip installation. With the variables set, run pip install from the project's root directory. pip will pass the environment variables down to Meson.
+
+.. code-block:: console
+    # Ensure you are in the project's root directory (where pyproject.toml is)
+    pip install .
+
+The build process will now use the compilers you specified instead of the system defaults.
+
+Method 2: Using a Meson Cross File (Advanced & Reproducible)
+------------------------------------------------------------
+
+For a more permanent or reproducible setup (e.g., in CI/CD pipelines or complex environments), a Meson "cross file" is the best practice. This file explicitly defines the toolchain.
+Step-by-Step Instructions
+
+1. Create a cross file. In your project's root directory, create a file named native-toolchain.ini (the name can be anything).
+
+2. Edit the file to specify the paths to your compilers in the [binaries] section.
+
+Example native-toolchain.ini:
+
+.. code-block:: console
+    # native-toolchain.ini
+    # Defines the compilers to use for the build.
+
+    [binaries]
+    c = '/path/to/my/custom/gcc'
+    fortran = '/path/to/my/custom/gfortran'
+
+    # If you also needed C++, you would add:
+    # cpp = '/path/to/my/custom/g++'
+
+Note: The keys are c, cpp, and fortran.
+
+3. Run the pip installation with meson-args. You can instruct pip to pass configuration settings to meson-python, which in turn passes them to Meson. We use this to specify our cross file.
+
+.. code-block:: console
+    # The --native-file option tells Meson which toolchain to use.
+    pip install . --config-settings=meson-args="--native-file=native-toolchain.ini"
 
+This method is more explicit and less prone to errors from shell configurations. It ensures that anyone building the project can easily use the exact same toolchain by sharing the native-toolchain.ini file.