Reference system

The example Mac OS installation described below was done on the following system:
Machine: MacBook Pro 2020
Operating system: macOS Big Sur 11.6.8
Processor: Intel Core i7, 2300 MHz, quad core
RAM: 16 GB

STEP 1: Download L-Galaxies 2020

OPTION 1: Clone GitHub repository (recommended):
This option requires having a GitHub account and Git on your Mac OS system. If you don't have Git already, download it following the instructions at: https://github.com/git-guides/install-git. Once you have Git and a GitHub account, proceed as follows:

  1. In the terminal, navigate to a directory where you'd like L-Galaxies kept
  2. Decide which branch you wish to download:
    • "master" for the Yates+21a version of L-Galaxies 2020
    • "Yates2023" for the Yates+24 version of L-Galaxies 2020 (recommended - contains latest updates)
  3. Clone the repository:
    • git clone --branch [BRANCH_NAME] --single-branch https://github.com/LGalaxiesPublicRelease/LGalaxies2020_PublicRepository


OPTION 2: Download zip file using browser:

  1. Go to https://github.com/LGalaxiesPublicRelease/LGalaxies2020_PublicRepository
  2. From the drop-down list on the left, select the branch you wish to download:
    • "master" for the Yates+21a version of L-Galaxies 2020
    • "Yates2023" for the Yates+24 version of L-Galaxies 2020 (recommended - contains latest updates)
  3. Click the green "Code" drop-down menu, and select "Download ZIP" [~5-20 MB]
  4. Move the downloaded file ([BRANCH_NAME].zip) to a suitable base directory.
  5. In the terminal (or otherwise), navigate to that base directory, then unzip the file:
    • unzip ./[BRANCH_NAME].zip
    This will create a new directory called /LGalaxies2020_PublicRepository-[BRANCH_NAME], hereafter, the "project root directory".
  6. You can now delete the .zip file, if you wish:
    • rm ./[BRANCH_NAME].zip
  7. Manually add an empty /output folder in the project root directory:
    • cd ./LGalaxies2020_PublicRepository-[BRANCH_NAME]
    • mkdir output


OPTION 3: Download zip file using curl:

  1. In the terminal, navigate to a directory where you'd like L-Galaxies kept
  2. Decide which branch you wish to download:
    • "master" for the Yates+21a version of L-Galaxies 2020
    • "Yates2023" for the Yates+24 version of L-Galaxies 2020 (recommended - contains latest updates)
  3. Download L-Galaxies 2020:
    • curl -O https://github.com/LGalaxiesPublicRelease/LGalaxies2020_PublicRepository/archive/[BRANCH_NAME].zip
  4. Unzip the file:
    • unzip ./[BRANCH_NAME].zip
    This will create a new directory called/LGalaxies2020_PublicRepository-[BRANCH_NAME], hereafter, the "project root directory".
  5. You can now delete the .zip file, if you wish:
    • rm ./[BRANCH_NAME].zip
  6. Manually add an empty /output folder in the project root directory:
    • cd ./LGalaxies2020_PublicRepository-[BRANCH_NAME]
    • mkdir output


OPTION 4: Download as a local Git repository via the Eclipse IDE:
The L-Galaxies 2020 code can also be obtained from GitHub via the Eclipse IDE, which offers a more intuitive way of editing and debugging code using a Graphical User Interface (GUI). To install L-Galaxies 2020 this way, skip straight to STEP 8 below, where information on how to install Eclipse and synchronise it with L-Galaxies 2020 is provided.

STEP 2: Download spectrophotometric tables and treefiles

  1. Download the standard SpecPhotTables [~1.6 GB] [direct download]
  2. Move the downloaded .tar file (SpecPhotTables.tar) into the project root directory.
  3. In the terminal, navigate to the project root directory.
  4. Untar the file:
    • tar -xf ./SpecPhotTables.tar
    This will create a folder called /SpecPhotTables containing the downloaded spectrophotometic tables
  5. The Millennium-I and Millennium-II treefiles have been pre-packaged into different sets,depending on how much of the simulation volume you want to use. You can choose from:
    6. Millennium-I: Millennium-II:
    • Treefiles 40-79 [~6.0 GB compressed, ~13 GB uncompressed] 40 treefiles (standard test set)
    • Treefiles 0-511 [~76 GB compressed, ~185 GB uncompressed] All treefiles (full volume)
  6. Download your chosen treefile set either by clicking the link above or in the command line using e.g. (for the test sets):
    • curl -O https://uhhpc.herts.ac.uk/~ry22aas/MR[II]_MergerTrees_[TREEFILE_NUMBERS].tar
  7. Move the downloaded .tar file into the /MergerTrees directory, which is in the project root directory.
  8. In the terminal, navigate to the /MergerTrees.
  9. Untar the treefiles:
    • tar -xzf ./MR[II]_MergerTrees_[TREEFILE_NUMBERS]
    This will create a folder called either /MR/treedata, /MRII/treedata, or /MRII containing the downloaded treefiles. Note that some macOS systems may try to untar your treefiles directly into a folder with the same name as the tar file itself (e.g. /MR_MergerTrees_5). In this case, you will either have to move the sub-folders inside back up to /MergerTrees, or change the path that L-Galaxies uses to looks for them in the input file (see STEP 7).

STEP 3: Check your compiler and C libraries

To compile and run L-Galaxies, a C compiler (e.g. gcc), the make command, and the GNU Scientific Libraries (GSL) are required. Mac OS distributions typically come with all three of these installed. Likewise, HDF5 is required if you wish to work with L-Galaxies outputs in HDF5 (rather than binary) format. You can check if gcc and make are installed on your system using the following commands, which return the directory where they are stored (usually /usr/bin/gcc and /usr/bin/make):

GSL is typically installed in /usr/local/include/gsl (for the header files) and /usr/local/lib (for the libraries). However, if Homebrew was used to install GSL, it might be found in /opt/homebrew/Cellar/gsl/[VERSION NUMBER]/include (for the header files) and /opt/homebrew/Cellar/gsl/[VERSION NUMBER]/lib (for the libraries) instead.

Similarly your HDF5 installation may be found in /opt/homebrew/include or /opt/homebrew/Cellar/hdf5/[VERSION NUMBER]/include (for the header files) and /opt/homebrew/lib or /opt/homebrew/Cellar/hdf5/[VERSION NUMBER]/lib (for the libraries).

If your system doesn't have gcc, make, GSL, or HDF5, the simplest way to install them on Mac OS is probably via Homebrew. If you have Homebrew, simply enter the following commands into the command line:

This should install them to their default locations (see above).

If all else fails, you can download the latest version of gcc from here, following the installation instructions provided here. Likewise, the make tool can be downloaded from here. The latest version of GSL can be downloaded from here, with installation instructions provided in the README and INSTALL files and general GSL documentation available here. The latest version of HDF5 can be downloaded from here.

STEP 4: Check the compiler configuration

The L-Galaxies 2020 makefile needs to be told which C compiler to use and where the GSL and HDF5 headers & libraries are stored. This information is provided by the user as a SYSTYPE configuration in the My_Makefile_compilers file, located in the project root directory.

By default, the SYSTYPE variable is set to "Linux". You can change this to the "Mac" configuration by commenting-out SYSTYPE = "Linux" at the top of the file and un-commenting SYSTYPE = "Mac". This set-up should be suitable for most Mac OS installations. It assumes the gcc compiler is to be used and that the GSL header files and libraries are stored in their default locations: /usr/local/include and /usr/local/lib. If your GSL files are not stored in these locations, you will need to change the GSL_INCL and GSL_LIBS paths accordingly (e.g. to their Homebrew locations).

Likewise, the "Mac" configuration also links to the two main HDF5 libaries required to get the HDF5_OUTPUT option working. Depending on your installation you may need to add additional explicit dependencies, such as: -lsz -laec -lz -ldl -lm

By default, O3 optimization is used. Feel free to add/change the OPTIMIZE flags for your compiler set-up, as you see fit.

If L-Galaxies 2020 compiles without any errors when you run the make command from the terminal in the project root directory, you are probably good to go! If not, here are a few common compiler issues and our (unofficial) suggested fixes:



Common compiler issues

  1. Running with an old C standard: If your distribution is quite old, it may not be running with the latest C standard. If so, you may need to inform the compiler of this in My_Makefile_compilers by adding the -std flag to the CC call. (e.g. CC = gcc -std=C99 for systems running with C99). When doing this, you may also need to manually define some extra constants in h_params.h that are not part of the standard math.h library in older C versions. For example: #define M_PI 3.14159265358979323846

  2. Running with old C libraries: Likewise, an old distribution may not have a version of the GNU C libraries (glibc). If so, you may need to install and build new C libraries following the instructions provided here (which is compilcated!). Alternatively, a quick hack (if you do have a recent version of the GSL libraries, see above), is to replace the #include <math.h> statements at the top of each L-Galaxies code .c file with #include <gsl/gsl_math.h>

  3. Multiple tentative definitions: If a compilation crashes with an error stating that "multiple tenative definitions of a global variable in different compilation units" are not allowed, you may need to add the -fcommon flag to the CC call in My_Makefile_compilers. Note that this flag is set by default when running with SYSTYPE = "cygwin".

  4. Shared and static libraries: Mac OS will usually use shared versions of C libraries by default. However, if you want to force the use of static libraries instead (i.e. .a files), then add the -static flag for GSL_LIBS in My_Makefile_compilers. Similarly, if you want to force the use of shared libraries (i.e. .dll or .so files), then add the -shared instead.

  5. Shared object errors: Similarly, if you are getting errors like: "Relocation R_X86_64_32 against undefined symbol '[LGALAXIES_PARAMETER]' can not be used when making a shared object", then you may need to add the -fPIC flag to the CC call in My_Makefile_compilers

STEP 5: Compile and run the code

Compiling and running L-Galaxies 2020 is done as follows:

  1. In the terminal, navigate to the project root directory
  2. Compile the code:
    • make
  3. Run the code:
    • ./L-Galaxies ./input/[INPUT FILE]


There are four standard input files to choose from (for info on which to use, see STEP 7):


Straight out of the box, L-Galaxies 2020 will run on treefile 5 of Millennium-I with only redshift 0 data outputted. So the input_MR_W1_PLANCK_LGals2020_MM.par input file is recommended in this case. However, various other standard set-ups are also possible (see STEP 7).

Once L-Galaxies 2020 has finished running, the output file(s) generated will be stored in the /output folder. These can be read in to python for analysis as described in STEP 6.

STEP 6: Reading-in and plotting outputs in python

L-Galaxies 2020 comes with a set of simple python scripts to read-in and plot L-Galaxies 2020 output files. These can be found in /AuxCode/Python. To run these python scripts on your outputs, simply execute the main_lgals.py file. This will generate a galaxy sample (using the selection criteria discussed below) which is saved to an .npy file in the /output/samples folder for quick re-use. It will also produce some plots in the /figures folder. To modify how main_lgals.py works, see below.


Note on HDF5 vs. binary outputs: By default, L-Galaxies 2020 will generate HDF5 output files, and main_lgals.py is set to read them in. This makes things easier than using binary output files, as the structure of the data doesn't need to be known a priori. However, if you prefer to work with binary output files, you can comment-out the HDF5_OUTPUT switch in the My_Makefile_options file before compiling & running L-Galaxies, and set the HDF5_OUTPUT switch in main_lgals.py to 0 when handling the outputs. Using binary files requires a python structure, which is automatically generated by L-Galaxies and saved in /AuxCode/Python as auto_LGalaxy_struct.py. Setting the STRUCT_TYPE option in main_lgals.py to "auto" will use this python structure when reading-in the L-Galaxies binary outputs. Other standard python structures are also stored in /AuxCode/Python, for reference.


Switches
The main_lgals.py file contains a number of switches under "USER DEFINED INPUTS" which can be used to modify how/what data is read-in and how it's handled. For example:


Sample Info
The type of L-Galaxies output to be read, and type of sample you want to generate, can also be set in main_lgals.py via the following variables:


Sample Types
There are four default sample types you can select when generating a sample from the L-Galaxies output file using main_lgals.py:

For more info on the exact selection criteria for these different sample types, see the make_lgals_sample.py file.


Note that the plots generated by these python scripts require LaTeX syntax for some of the axis labels. If your MacOS installation does not have (La)TeX capabilities, you may need to install the following:


For more information on how to use/modify these python scripts, feel free to drop me an email (r.yates3 -at- herts.ac.uk).

STEP 7: Changing the model [OPTIONAL]

Default vs. Modified model
Input files (i.e. the .par files) are provided for the Default Model (DM) and Modified Model (MM) versions of L-Galaxies 2020 (see Yates+21a for details). In brief, the Default Model allows the majority of material released by supernovae and stellar winds to mix with the ambient ColdGas before some is blown out as galactic winds. The Modified Model allows the majority of this newly-released material to be directly ejected into the surrounding HotGas, without first mixing with the ColdGas. The Modified Model is recommended, as it more accurately reproduces the chemical evolution of galaxies and their surroundings above redshift 0 (see Yates+21a). You can select the Default Model or Modified Model by using the an input file with a "DM" or "MM" suffix, respectively.



Millennium-I vs. Millennium-II
By default, L-Galaxies 2020 will try to run on Millennium-I merger trees. To switch to Millennium-II, make sure you've downloaded some Millennium-II treefiles (see STEP 2), and then do the following:

  1. Open the My_Makefile_options file in the project root directory
  2. Uncomment the MRII switch
  3. Save and close My_Makefile_options
  4. Use the default model (DM) or modified model (MM) Millennium-II input files as the argument when running the code (see STEP 5 above):
    • input_MRII_W1_PLANCK_LGals2020_DM.par
    • input_MRII_W1_PLANCK_LGals2020_MM.par



Snapshot vs. Galaxytree mode
Snapshot mode (the default for L-Galaxies 2020) will only output data for a user-defined set of redshifts (i.e. snapshots). Galaxytree mode will instead output data from all snapshots, along with the IDs needed to link a given galaxy to its progenitors and descendents (note that this generates much larger output files).

To use/modify snapshot mode:

  1. Open desired_output_redshifts.txt in the /inputs folder
  2. Add the redshifts you wish to be outputted to the top of this file, one on each line, with an empty line at the end of your list (L-Galaxies will match these to their nearest snapshots automatically)
  3. Open the My_Makefile_options file in the project root directory
  4. Set the NOUT parameter to equal the number of redshifts you set to be outputted in desired_output_redshifts.txt
  5. Make sure that the GALAXYTREE switch is commented-out
  6. Save and close My_Makefile_options
  7. Compile and run L-Galaxies 2020 as described in STEP 5

To use galaxytree mode:
  1. Open the My_Makefile_options file in the project root directory
  2. Uncomment the GALAXYTREE switch
  3. Save and close My_Makefile_options
  4. Compile and run L-Galaxies 2020 as described in STEP 5



MCMC mode
For detailed instructions on how to run L-Galaxies in MCMC mode, in order to retune model parameters, see the MCMC instructions kindly provided by Marcel van Daalen.



Changing the output file name

  1. Open the input file you wish to use (see above) in the /inputs folder
  2. Change FileNameGalaxies to an appropriate name. This will be the prefix in the name of the output file(s) that L-Galaxies generates.
  3. Save and close the input file
  4. Compile and run L-Galaxies 2020 as described in STEP 5
  5. Remember to modify the variables used to read-in L-Galaxies outputs in main_lgals.py too (e.g. the VERSION variable).



Changing the treefiles used

  1. Open the input file you wish to use (see above) in the /inputs folder
  2. Set FirstFile to the first treefile you wish to use
  3. Set LastFile to the last treefile you wish to use
  4. Save and close the input file
  5. Compile and run L-Galaxies 2020 as described in STEP 5
  6. Remember to modify the variables used to read-in L-Galaxies outputs in main_lgals.py too (i.e. FirstFile and LastFile).

To run L-Galaxies 2020 on the full set of Millennium-I or II trees, set FirstFile to 0 and LastFile to 511. For testing purposes on Millennium-I, treefile 5 alone is normally sufficient. For quick but statistically-significant runs on Millennium-I, treefiles 0-9 are normally sufficient. For quick but statistically-significant runs on Millennium-II, treefiles 40-79 are normally sufficient.



Model switches
L-Galaxies 2020 comes with a series of pre-defined model options (or "switches") that change the physics models used, the treefiles used, which properties are tracked/outputted, etc. These switches are defined in the My_Makefile_options file in the project root directory. There meanings should be quite self explanatory, but if you are unsure, feel free to ask! You are also able to add your own switches to your version of the code. These should be defined in My_Makefile_options and then utilised in the necessary code files via "ifdef statements" (or equivalent). For example, to create a switch which prevents the property BulgeMassRings from being outputted:

  1. Open My_Makefile_options in the project root directory
  2. Add the following line:
    • OPT += -DNO_BULGEMASSRINGS_OUTPUT
  3. Save and close My_Makefile_options
  4. Put the following ifdef statement around the instances of BulgeMassRings in h_galaxy_output.h and save.c (see below for more details):
    • #ifndef NO_BULGEMASSRINGS_OUTPUT
    • ...
    • #endif //NO_BULGEMASSRINGS_OUTPUT
  5. Save and close the code files
If working with binary output files, this modification will be automatically updated in the python structure saved in /AuxCode/Python/ as auto_LGalaxy_struct.py during compilation.



Changing which properties are outputted

You are free to customise which properties are actually outputted by L-Galaxies 2020. This is done as follows:

  1. Open h_galaxy_output.h in the /code folder
  2. In the GALAXY_OUTPUT structure, add/comment-out the property you wish to be outputted/not outputted
    3. For example, to remove BulgeMassRings, either put it in a newly-defined #ifndef (see above) or directly comment it out:
    • // float BulgeMassRings[RNUM];
  3. Save and close h_galaxy_output.h
  4. Open save.c in the /code folder
  5. In the prepare_galaxy_for_output() function, add/comment-out the property you wish to be outputted/not outputted
    6. For example, to remove BulgeMassRings, either put it in a newly-defined #ifndef (see above) or directly comment it out:
    • // o->BulgeMassRings[ll] = g->BulgeMassRings[ll];
  6. Save and close save.c
If running with the HDF5_OUTPUT switch on, all your modifications will automatically be known by main_lgals.py when reading-in your newly-generated output files. If running with binary output files, as mentioned above, the python structure required is automatically saved in /AuxCode/Python/ as auto_LGalaxy_struct.py during compilation. However, if you are working with a manually-edited python structure of your own, make sure to modify it to reflect the new set of properties you are outputting.

Note: The majority of errors occurring when trying to read-in L-Galaxies output binaries come from a mis-match between the actual output contents and the python structure! Therefore, make sure you keep your output structure up-to-date with your code!



Changing chemical elements to track [Yates2023 branch only]
The Yates23 version of L-Galaxies allows the inclusion of chemical yields for 118 chemical elements (totaling 487 individual isotopes) from stellar populations calculated utilising the binary stellar evolution (BSE) code, binary_c. To do this, "ensemble" outputs from binary_c are loaded and converted into yield tables that can be read by L-Galaxies.

Standard tables are pre-generated and stored in /YieldTables/binary_c_yields/default/. These contain the following elements: ['H','He','C','N','O','Ne','Mg','Si','S','Ca','Fe']. If a different set of chemical elements (or isotopes) is required, or if you want to use a new set of binary_c ensembles, new yield tables can be easily generated and used, as follows:

  1. Modify the element list in process_binaryc_outputs.py:
    • In ./AuxCode/Python/process_binaryc_outputs.py, modify the elements array (line ~ 76) to include the elements and isotopes you want.
    • Note: The fewer elements you include in this array, the quicker L-Galaxies will run and the smaller the output files will be. However, the list must include at least ['H','He'] (for the infall model), and the following are also required for the dust model: ['C','O','Mg','Si','Fe'].
    • If you also want to generate the yield tables for a completely new set of binary_c ensembles (rather than the standard ones), simply place the new ensemble .json files into the /YieldTables/binary_c_yields/new/ensembles folder and set USE_NEW_ENSEMBLES = 1 in process_binaryc_outputs.py before running this script.
  1. Run the process_binaryc_outputs.py script:
    • This will generate your new set of yield tables and place them in ./YieldTables/binary_c_yields/new/, along with a .txt file containing useful metadata.
    • A new h_metals.h file will also be created in the ./code/ folder, which L-Galaxies will automatically use. The old metals header file will automatically be copied to h_metals_old.h, for reference.
  1. Switch-on the USE_NEW_YIELDS option in My_Makefile_options:
    • This will tell L-Galaxies to read-in the new yield tables, rather than the standard ones.
You should then be able to make and run L-Galaxies as usual (see STEP 5). The L-Galaxies python scripts to read, process, and plot output data (see STEP 6) will automatically read the new chemical element list and handle everything correctly.

For more information on how to handle binary_c data with L-Galaxies, feel free to drop me an email (r.yates3 -at- herts.ac.uk).

STEP 8: Running L-Galaxies in the Eclipse IDE [OPTIONAL]

Although L-Galaxies 2020 can be used with any basic word processor and the command line, using an Interactive Development Environment (IDE) can make modifying, compiling, running, and debugging code significantly easier and more efficient. This can save a lot of time and energy in the long run. Therefore, we recommend an IDE (that is compatible with C makefile projects) is used when working with L-Galaxies. Below, we outline how to download, install, and synchronise the Java-based Eclipse IDE for L-Galaxies, which has already been extensively tried and tested with the code.


Check C compiler and libraries:

  1. If you haven't already, complete STEP 3 above to install the gcc compiler, make, and GSL.


Install jdk:
Eclipse is a java-based IDE, so it needs the Java Development Kit (JDK) to run. You can check if JDK is already installed on your system by running java -version in the command line. If this command returns information on a Java "Runtime Environment", you probably have a working version of JDK installed. If you don't have JDK, you can install the latest version as a private user as follows:

  1. Go to: https://www.oracle.com/java/technologies/downloads/#jdk19-mac
  2. Click the download link for the Java SE Development Kit 19.0.1 x64 DMG Installer
  3. Double-click the downloaded .dmg file. Double-click the exported .pkg file
  4. Install to the default location: /Library/Java/JavaVirtualMachines/jdk-19.jdk/Contents/Home/


Install Eclipse IDE:

  1. Go to: https://www.eclipse.org/downloads/packages/installer
  2. Click the download link for the Eclipse 2022-09 R x86_64 Installer for macOS (probably the x86_64 version, unless you have AArch64 system architecture)
  3. Once downloaded, execute the installer (called eclipse-inst-jre-mac64.dmg)
  4. Select: Eclipse IDE for C/C++ Developers
  5. Confirm: Java 17+ VM: /Library/Java/JavaVirtualMachines/jdk-19.jdk/Contents/Home and Installation Folder: /Users/[username]/eclipse/cpp-2022-09
  6. Click "install"
  7. Accept the user agreement
  8. Once it's installed, click "launch"
  9. Confirm: Workspace: Users/[username]/eclipse-workspace and click "launch" again.


Clone L-Galaxies 2020 repository:

  1. "Hide" the welcome screen
  2. In the Eclipse IDE, click the "Open Perspective" button in the top right corner (symbol of a GUI interface with a plus sign)
  3. Select "Git"
  4. Click "Clone a Git Repository" (left)
  5. Enter the L-Galaxies 2020 repository URI: https://github.com/LGalaxiesPublicRelease/LGalaxies2020_PublicRepository
  6. Click "Next"
  7. Select which branch(es) you wish to clone and click "Next"
  8. Confirm the destination directory (this will become your git-synchronised project root directory).
  9. Click "Finish"
    10. Eclipse will now clone a local version of the L-Galaxies 2020 repository (progress bar in the bottom right corner)
  10. Once cloned, two-finger click the name of the project in the left-hand panel (LGalaxies2020_PublicRepository)
  11. Click "Import projects..."
  12. In the new window, click "Finish"
    13. The L-Galaxies 2020 code is now ready to be used in the standard "C/C++ Perspective" in Eclipse.


Define as a makefile project:

  1. Click the "C/C++ Perspective" button in the top right corner (symbol of a GUI interface with a letter "C")
  2. Click on the project name in the left-hand panel (LGalaxies2020_PublicRepository), so that it's highlighted
  3. Press Ctrl+n on the keyboard
  4. Select: "Convert to C/C++ project (Adds C/C++ Nature)" and click "Next"
  5. Under "Convert to C or C++", select "C project"
  6. Under "Project Options", select "Makefile project" and the "MacOSX GCC" toolchain
  7. Click "Finish"


Set-up a run configuration:

  1. In the "C/C++ perspective", click the project name in the left-hand panel (LGalaxies2020_PublicRepository), so that it's highlighted
  2. From the top menu bar, select "Run" > "Run configurations..."
  3. In the new window (left-hand panel), click "C/C++ Allpication"
  4. Click the "New Launch configuration" button (symbol of a blank page with a plus sign)
  5. In the right-hand panel, set "Name" to: "LGalaxies2020_PublicRepository" (i.e. delete " Default")
  6. Set "C/C++ Application" to: "L-Galaxies"
  7. Click the "Arguments" tab (right-hand panel)
  8. Under "Program arguments", add the local path to your preferred input file (e.g. ./input/input_MR_W1_PLANCK_LGals2020_DM.par)
  9. Click "Apply", then click "Close"


Add an output folder:

  1. In the "C/C++ perspective", two-finger click the project name in the left-hand panel (LGalaxies2020_PublicRepository)
  2. Select "New" > "Folder"
  3. In the new window, set Folder name as "output"
  4. Click "Finish"


Download treefiles and specphot tables:

  1. If you haven't already, complete STEP 2 above for this cloned L-Galaxies 2020 repository


Check compiler configuration:

  1. Complete STEP 4 above to check the gcc compiler is configured correctly for L-Galaxies 2020 on your system. For example, you may need to set the SYSTYPE to "Mac" in My_Makefile_compilers.


Compile and run in Eclipse:

  1. In the "C/C++ perspective", click the project name in the left-hand panel (LGalaxies2020_PublicRepository), so that it's highlighted
  2. To compile: Click the "Build" button in the top left corner (symbol of a hammer)
  3. To run: Click the "Run" button in the top left corner (symbol of a green "play" sign)