# Dock the AlphaFold model

We’ll use the AlphaFold model as a starting model and first we need to fit this in the map.

We will use an `em_placement` job to perform a fast 6D search (rotation and translation) to find the locations and orientations that fit the map best.

The `em_placement` job runs a global search with the whole map for the best fit. There is a related `emplace_local` job that performs a local search, but we will use the global search here.
From the `NEW JOB` tab, find `em_placement` in the `Atomic Model Fit` section and enter the following (leaving the other parameters with the default settings):

```params
Model to dock:: Fetch/jobXXX/AF-P00722-F1-model_v6.cif
NOTE: In this tutorial, where we have put “jobXXX” you will need to replace this with the number of the correct job in your project, which might not always be the same if you run any extra jobs. Usually, Doppio will suggest appropriate input files for you and you will just need to select the right one.
FASTA Sequence:: Fetch/jobXXX/P00722.fasta
Input half map 1:: Refine3D/job029/run_half1_class001_unfil.mrc
Input half map 2:: Refine3D/job029/run_half2_class001_unfil.mrc
Best resolution:: 2.9
```

Be careful to ensure that you use `run_half2_class001_unfil.mrc` instead of repeating `run_half1_class001_unfil.mrc` for Input half map 2.

Click `RUN` to start the job. The job will take a few minutes to complete.

Click on the `RESULTS` tab, here you should be able to see the AlphaFold model successfully docked into the 3D map. 

## Inspect em_placement results

You can assess the quality of the fit visually using the 3D viewer i.e. does the model fit the contours of the map region it is docked in, and quantitatively by the mapLLG score.

```{image} ../_static/images/ModelBuilding/2_EM_Placement_results.png
:align: center
:scale: 100%
```

The key metric here is the mapLLG score, this is the log likelihood gain. The likelihood explains the probability of a data set given a model. The log likelihood gain explains the difference between the logarithm of likelihood for a tested model and an uninformative model.

A mapLLG score of **more than 60** usually indicates that the model fit is correct. 

If you run em_placement with the map in the wrong handedness you will get a score of around <54 (in this dataset) which indicates something is wrong, a visual inspection will confirm and show a poor fit.

The tutorial data and AlphaFold model are very good in this case, and you will see scores of >3000. A quick visual inspection shows a good looking fit in all regions.

**Note the model with the highest mapLLG score** (`docked_model1.pdb` in this case), we will use that in later steps. 

## Checking the handedness

This step is optional and can be skipped.
 
It is not usually possible to determine absolute handedness from a data set without tilting the microscopy stage. The SGD algorithm in the Initial Model job therefore has a 50% chance of being in the incorrect hand (and every map that follows in subsequent jobs would inherit the incorrect handedness). One way to check this is to try fitting an atomic model in both hands.

Examine the results of the `em_placement` job. If the model doesn’t look like it fits well in the map the map’s handedness may be incorrect (if using the precalculated results from the RELION 5 tutorial it should be correct).

To help visualise the model in the map you can adjust the Opacity and Iso Value (a.k.a. contour value) from the Volume menu in the Mol* graphical viewer in the `RESULTS` tab.

The `Flip map handedness` job in `Map Utilities` can be used to flip the maps if this is the case. You will need to run this for multiple maps for downstream processing. Add additional maps to the input with the `+` button next to the file inputs

```params
Input map::	PostProcess/job030/postprocess.mrc, PostProcess/job030/postprocess_masked.mrc, Refine3D/job029/run_half1_class001_unfil.mrc, Refine3D/job029/run_half2_class001_unfil.mrc, Refine3D/job029/run_class001.mrc
```

Run the Flip job, then clone the previous `em_placement` job by clicking on its “three dots” icon and selecting `Clone job`. Change `Input half map 1 and 2` to the flipped half maps generated from the flip map job, run it and compare visual fit and mapLLG scores.

## Map preparation

It’s often useful to make various additional maps to help with visualisation and interpretation. These can range from quite simple and “safe” operations such as global B-factor sharpening or blurring, through to more “dangerous” map enhancements that can claim to increase the map resolution or improve the clarity of map features, but with the risk of hallucinating realistic-looking features that are not actually supported by the experimental data.

Here we will run one tool called LAFTER, which is quite a safe option. It locally denoises maps by identifying features in each resolution shell that are shared between the two half maps, so you can reasonably interpret the output as a consensus map – if a feature is present in the LAFTER map it means that it is present in both half maps and so is unlikely to be purely noise. This can be a useful complement to sharpened or enhanced maps, to check that you are not optimistically interpreting noise peaks as real molecular density.

Find the `LAFTER` job (in the `Map Postprocessing` section) and enter the following options:

```params
Input map 1 (half map 1)::  Refine3D/job029/run_half1_class001_unfil.mrc
Input map 2 (half map 2)::  Refine3D/job029/run_half2_class001_unfil.mrc
Input mask::  MaskCreate/job020/mask.mrc
```

Run the job. Have a look at the output map now if you like, but it will be most useful to load it into Moorhen or Coot later when looking at fitted and refined models as an aid to interpretation.

Servalcat also produces a “normalised expected map” from each refinement job. This is a map that is globally sharpened based on the variance between the two half maps. In well-resolved regions it often looks very similar to the LAFTER map, but in regions with low local resolution they can be quite different. In those areas, LAFTER is usually a good guide to the reliable low-resolution features, while the post-processed and Servalcat maps can show higher-resolution features that should be interpreted with caution.