Download_Installation.qmd

---
title: "Download & Installation"
author: "Cox Lab"
engine: knitr
format:
  html:
    toc: true
    toc-depth: 4
    toc-expand: true
    number-sections: true
    number-depth: 4
editor: visual
date: today
bibliography: references.bib
execute:
  eval: false
---

# Download

Downloading and using the software is free of charge.

Simply download from [here](https://maxquant.org/) and unpack the compressed file `MaxQuant.zip`.

# Running

Please choose your operating system to view how to run MaxQuant.

## MaxQuant on Windows {#sec-mq-windows}

Supported operation system versions (64-bit is required) are Windows 10 or 11 or Windows Server 2016, 2019, 2022.

-   **Install .NET Core 8.0 or higher**: To find out whether you already have it, you can either open the following path. We recommend using version 8.0.302 at least, as it solves some bugs with the GUI.

```{bash}
C:\Program Files\dotnet\sdk
```

or run the following command in the terminal (Win+R -\> `cmd`):

``` bash
dotnet --version
```

If you need to, you can download the software and get installation instructions  e.g. [for .NET 8.0 here](https://dotnet.microsoft.com/en-us/download/dotnet/8.0).

~~.NET 3.1 and older versions are not supported anymore.~~

MaxQuant now works with .NET \>= 8.0.302

-   **Run MaxQuant GUI** Double click on `MaxQuant.exe` in the `MaxQuant` folder and specify your RAW files, experimental design and fasta files.

-   **Start MaxQuant** Click on the `Start` button.

## MaxQuant on Linux

We are supporting MaxQuant on Ubuntu 20.04 or higher, but MaxQuant should also work on other distributions of Linux.
~~You may run MaxQuant using Graphical User Interface~~. MaxQuant on Linux doesn't support the use of a GUI at the moment. We're planning to make it available in future versions, [so stay tuned to our newletter](https://maxquant.org/newsletter/), where we'll inform our users about new updates.  

This tutorial is focused on running MaxQuant using the command-line.

-   **Install .NET Core 8.0** To find out whether you already have it, type in the command line

``` bash
dotnet --version
```

If you see at least version $8.0.302$, then everything is ready to start MaxQuant.

Otherwise you need to follow the installation instructions at [.NET Core SDK 8.0](https://dotnet.microsoft.com/en-us/download/dotnet/8.0) for your operating system.

### Global installation on Ubuntu using `sudo` permissions

Ubuntu 22.04 (for example)

``` bash
wget https://packages.microsoft.com/config/ubuntu/20.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb
sudo apt-get update; \
sudo apt-get install -y apt-transport-https && \
sudo apt-get update && \
sudo apt-get install -y dotnet-sdk-8.0
```

### local installation using the `conda` environment

An alternative installation method, which might work better, if no `sudo` rights are available for the user would be to use the `conda` [@anaconda] environment.

Depending on your architecture, the user must choose between the x86 and the Arm installation scripts.
Both can be downloaded from the [anaconda repository](https://repo.anaconda.com/miniconda/) using the `wget` command.

``` bash
# Or use conda to install an environment
## get the installer 
mkdir -p ~/miniconda3
# for 64x-bit 86x architecture
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda3/miniconda.sh
# for 64-bit arm architecture
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-aarch64.sh -O ~/miniconda3/miniconda.sh

### You'll only need one the above two scripts!!!

# Install the conda base env
bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3
rm -rf ~/miniconda3/miniconda.sh
```

Before one can use the `conda` environment in your shell, it must be initialized and the session restarted.
Another tip would be to install the mamba package, but **this is only optional** and is not needed, if you're using conda on a regular basis.
(If you do, you probably already installed mamba 😀).

``` bash
# initialize conda on bash 
~/miniconda3/bin/conda init bash
~/miniconda3/bin/conda init zsh
# logging out and back in again
conda install conda-forge::mamba
mamba init 
#Here again, one must log out and back in again for mamba to be active. 
```

Now, using the `mamba`command one can create a new environment for `dotnet`.
One can either choose a specific version for `dotnet` or by omitting the version number, the latest available version on the anaconda repository will be installed.
You can search [here](https://anaconda.org/search?q=dotnet) for possible versions.

Before you can use the tool, you must activate the environment.
Last check to see if the installation was successful, one can check for the available `dotnet` version.

``` bash
#Now we create `dotnet` env
# create the dotnet env
mamba create -n dotnet8 conda-forge::dotnet=8.0.302
mamba activate dotnet8
#To test that we do have `dotnet`
dotnet --version
```

### Scripted installation using Microsoft resources.

One can also follows Microsoft's instruction to install the (optional) latest version of`.NET` by following the script [here](https://dotnet.microsoft.com/en-us/download/dotnet/8.0).

A manual install has more options to choose from using the `dotnet-install` script from the [.NET page](https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-install-script).

``` bash
wget https://dot.net/v1/dotnet-install.sh -O dotnet-install.sh
chmod +x ./dotnet-install.sh
./dotnet-install.sh --channel 8.0
```

Possible important options here are:

-   `--channel` - use this to ask for a specific version and/or subversion
-   `--version` - install a specific version
-   `--install-dir` - use this to specify the path to the installation directory.

We also added a script for an automated installation of the .NET which can also be downloaded [here](Install_dotnet.sh).
Running the script will ask the user for a download location, where, for now, .NET version 8.0.302 will be installed.
This version was needed due to a bug in Perseus.

After downloading the script it needs to be made executable and can be run as such:

```{bash}
chmod -x Install_dotnet.sh
sh Install_dotnet.sh INSTALLATION_PATH/
```

This will download the .NET installation script from Microsoft and will install the tool at the given path.
no `sudo` rights are needed.

## Edit mqpar.xml file

Currently we highly recommend to pre-configure the `mqpar.xml` file in MaxQuant GUI. After transferring the file on Linux machine, do not forget to update file addresses accordingly.
You can also use a programmatic way to change that. 

If you use on-the fly prediction use this command: 

If you use on-the-fly prediction use this command:

``` bash
dotnet MaxQuant/bin/MaxQuantCmd.dll old_mqpar.xml --changeFolder new_mqpar.xml <new folder with fasta files> <new folder with raw files> 
```

<<<<<<< Updated upstream
If you use predicted libraries, you need to also add the path to the saved libraries, so use this command:
=======
If you use predicted libraries, you also need to add the path to the saved libraries, so use this command:
>>>>>>> Stashed changes

``` bash
dotnet MaxQuant/bin/MaxQuantCmd.dll old_mqpar.xml --changeFolder new_mqpar.xml <new folder with fasta files> <new folder with raw files> <new folder with libraries> 
```

However if you feel familiar with a structure of `mqpar.xml`, you may create a template of `mqpar.xml` and edit it directly.

``` bash
dotnet MaxQuant/bin/MaxQuantCmd.dll --create new_mqpar.xml
```

## Run MaxQuant

``` bash
dotnet MaxQuant/bin/MaxQuantCmd.dll mqpar.xml
```

# Hardware requirements

-   4 GB RAM minimum.
-   4 GB RAM per thread that is executed in parallel is required.
-   There is no upper limit on the number of cores. Whatever you can fit into a shared memory machine will work as long as the disk performance scales up with it.

Here we list some example hardware configurations that we are using in the lab and that we are quite happy with.
These are mere examples and there is no reason to prefer specific vendors or brands.

### Dell PowerEdge R820 (Intel)

-   4x Intel® Xeon® E5-4640 2.40GHz, 20M Cache, 8.0GT/s QPI, Turbo, 8C, 95W
-   128GB Memory for 4CPU (16x8GB RDIMM, 1600 MHz, Standard Volt, Dual Rank, x4)
-   PERC H710p integrated RAID Controller, 1GB NV Cache
-   6x 900GB, SAS 6Gbps, 2.5-in, 10K RPM Hard Drive (Hot Plug)
-   RAID-0
-   OS: Microsoft Windows Server 2012 Standard

### Standard PC

-   Processor: Intel® Core i7-2600 Processor (8M Cache,3.40 GHz)
-   OS: English original Windows® 7 Professional(64-Bit)
-   RAM: 16GB (4X4GB) 1333 MHz DDR3 Non-ECC 489916 1 \[370-20205\] 3
-   Primary Hard Drive: 256GB SSD Solid State Drive
-   Additional Hard Drive: 2TB (7.2k rpm) Serial ATA II with NCQ and 16MB Data Burst Cache
-   Graphics card: 512MB AMD Radeon HD 6350
-   USB 3.0: USB 3.0 PCI-Card
-   To improve the processing speed the SSD can also be used exclusively for MaxQuant
-   USB 3.0 convenient for fast file transfer, 500MByte/s (USB 2.0 = 60MByte/s)
-   Hard drives can of course be larger depending on the respective sizes of your projects and wallet.

### 'Monster' PC

-   Coolermaster HAF 922 Black Tower Case
-   2 x Front USB 2.0 and Audio ports
-   750W EPS12V Quiet power supply
-   Additional Red LED 200mm Case Fans
-   Asus Sabertooth P67 Intel i7 Skt1155ATX motherboard With 2 x 16x 2.0 PCI-Express slot, 3 x PCI-e x1 slot, SATAIII 4 x DDR3 memory slots, Audio, 10/100/1000 LAN, SATAII, & USB 3.0/USB 2.0 ports
-   Intel i7 2600K 3.4GHz Quad Core 8MB cache Skt1155 Unlocked processor
-   Corsair Vengeance 32GB (4 x 8GB) DDR3 1866MHz Quad Channel memory
-   Western Digital 500GB Caviar Black SATAIII disk drive
-   1GB Nvidia Geforce GT430 PCI-e x16 2.0 graphics card
-   Black DVD+/- R RW Dual Layer drive
-   LSI 9260-8i 8port SAS 6Gb/s PCI-Express RAID controller
-   Battery Backup for RAID controller
-   2 x Crucial 512MB Solid State Disks
-   Thanks to Peter McHardy for assembling this configuration

------------------------------------------------------------------------

For questions or problems with the installation we would love to hear from you under [Contact](contact.html).