modelcraft 4.0.1__tar.gz → 5.0.0__tar.gz

{modelcraft-4.0.1/modelcraft.egg-info → modelcraft-5.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: modelcraft
-Version: 4.0.1
+Version: 5.0.0
 Summary: Automated model building pipeline for X-ray crystallography
 Home-page: https://github.com/paulsbond/modelcraft
 Author: Paul Bond

{modelcraft-4.0.1 → modelcraft-5.0.0}/modelcraft/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.0.1"
+__version__ = "5.0.0"
 
 from .cell import max_distortion as max_cell_distortion
 from .cell import remove_scale

{modelcraft-4.0.1 → modelcraft-5.0.0}/modelcraft/arguments.py

@@ -241,25 +241,27 @@ _GROUP.add_argument(
 
 _EM = _SUB_PARSERS.add_parser("em", parents=[_PARENT], formatter_class=_FORMATTER)
 _GROUP = _EM.add_argument_group("required arguments (em)")
-_GROUP.add_argument(
-    "--map",
-    required=True,
-    nargs="+",
+_MAP = _GROUP.add_mutually_exclusive_group(required=True)
+_MAP.add_argument(
+    "--half-maps",
+    nargs=2,
     metavar="X",
     help=(
-        "Either two half-maps or a single map in MRC format. "
-        "Input maps will be trimmed using Servalcat. "
-        "If two half-maps are provided then Servalcat will be used to calculate "
+        "Unsharpened, unweighted half-maps in MRC format for use in refinement. "
+        "This option is preferred over providing a single map. "
+        "If the --build-map argument is not provided "
+        "then Servalcat will be used to calculate "
         "a normalised expected (NE) map for model building."
     ),
 )
-_GROUP.add_argument(
-    "--mask",
+_MAP.add_argument(
+    "--single-map",
     metavar="X",
     help=(
-        "Mask with the same grid size and dimensions as the input map(s). "
-        "Servalcat will use this mask when trimming the maps. "
-        "If a mask is not provided then EMDA mapmask will be used to create one."
+        "A single unsharpened, unweighted map in MRC format for use in refinement. "
+        "Only use this option if you do not have two half-maps available. "
+        "If the --build-map argument is not provided "
+        "then this map will also be used for model building. "
     ),
 )
 _GROUP.add_argument(
@@ -267,19 +269,33 @@ _GROUP.add_argument(
     type=float,
     required=True,
     metavar="X",
-    help="High resolution limit in Angstroms",
+    help=(
+        "Best resolution (high resolution limit) in Angstroms. "
+        "Using a higher resolution (a smaller number) reduces the grid spacing, "
+        "which may give better results at the cost of slower calculations."
+    ),
 )
+_GROUP = _EM.add_argument_group("optional arguments (em)")
 _GROUP.add_argument(
-    "--blur",
-    default=0.0,
-    type=float,
+    "--build-map",
+    metavar="X",
+    help=(
+        "Optimally-sharpened map (e.g. from LocScale) for use in model building. "
+        "If this is not provided then a normalised expected (NE) map "
+        "will be calculated from the two half-maps. "
+        "If half-maps were not provided then the single map will be used."
+    ),
+)
+_GROUP.add_argument(
+    "--mask",
     metavar="X",
     help=(
-        "B-factor for global blurring or sharpening of the input map "
-        "(positive values for blurring and negative values for sharpening). "
-        "This value is only used if a single input map is provided. "
-        "If two half-maps are provided then local blurring and sharpening "
-        "is performed in the calculation of the normalised expected (NE) map."
+        "Mask for trimming the input maps in MRC format, "
+        "with the same grid size and dimensions as the input maps. "
+        "Having a box size that is too large will lead to worse building results, "
+        "slow down the programs, and make the FSC calculation less accurate. "
+        "If this argument is set to 'auto' "
+        "then EMDA mapmask will be used to create a mask."
     ),
 )
 
@@ -303,25 +319,30 @@ def _basic_check(args: argparse.Namespace):
         _PARSER.error(f"--threads must be between 1 and {(os.cpu_count() or 1)}")
     if args.mode == "em" and args.resolution <= 0:
         _PARSER.error("--resolution must be greater than 0")
-    if args.mode == "em" and len(args.map) > 2:
-        _PARSER.error("--map only takes two half-maps or a single map")
-    if args.mode == "em" and len(args.map) == 2 and args.blur != 0.0:
-        _PARSER.error("--blur can only be used with a single map and not two half-maps")
 
 
 def _check_paths(args: argparse.Namespace):
-    for arg in ("contents", "data", "map", "mask", "model", "restraints"):
+    for arg in (
+        "build_map",
+        "contents",
+        "data",
+        "half_maps",
+        "mask",
+        "model",
+        "restraints",
+        "single_map",
+    ):
         if hasattr(args, arg):
             attr = getattr(args, arg)
-            if isinstance(attr, str):
+            if isinstance(attr, str) and attr != "auto":
                 if not os.path.exists(attr):
-                    _PARSER.error("File not found: %s" % attr)
+                    _PARSER.error(f"File not found: {attr}")
                 attr = os.path.abspath(attr)
                 setattr(args, arg, attr)
             if isinstance(attr, list):
                 for i, path in enumerate(attr):
                     if not os.path.exists(path):
-                        _PARSER.error("File not found: %s" % path)
+                        _PARSER.error(f"File not found: {path}")
                     attr[i] = os.path.abspath(path)
 
 

{modelcraft-4.0.1 → modelcraft-5.0.0}/modelcraft/jobs/servalcat.py

@@ -49,12 +49,12 @@ class ServalcatNemap(Job):
 @dataclasses.dataclass
 class ServalcatTrimResult:
     mask: gemmi.Ccp4Map
-    maps: list
+    maps: dict
     seconds: float
 
 
 class ServalcatTrim(Job):
-    def __init__(self, mask: gemmi.Ccp4Map, maps: list):
+    def __init__(self, mask: gemmi.Ccp4Map, maps: dict):
         super().__init__("servalcat")
         self.mask = mask
         self.maps = maps
@@ -64,21 +64,20 @@ class ServalcatTrim(Job):
         self.mask.write_ccp4_map(self._path("mask.ccp4"))
         self._args += ["--mask", "mask.ccp4"]
         self._args.append("--maps")
-        for i, map_ in enumerate(self.maps):
-            map_.write_ccp4_map(self._path(f"map{i}.ccp4"))
-            self._args.append(f"map{i}.ccp4")
+        for name, ccp4_map in self.maps.items():
+            ccp4_map.write_ccp4_map(self._path(f"{name}.ccp4"))
+            self._args.append(f"{name}.ccp4")
         self._args.append("--noncubic")
         self._args.append("--noncentered")
         self._args.append("--no_shift")
 
     def _result(self) -> ServalcatTrimResult:
-        self._check_files_exist("mask_trimmed.mrc", "map0_trimmed.mrc")
+        self._check_files_exist("mask_trimmed.mrc")
         return ServalcatTrimResult(
             mask=read_map(self._path("mask_trimmed.mrc")),
-            maps=[
-                read_map(self._path(f"map{i}_trimmed.mrc"))
-                for i in range(len(self.maps))
-            ],
+            maps={
+                name: read_map(self._path(f"{name}_trimmed.mrc")) for name in self.maps
+            },
             seconds=self._seconds,
         )
 

{modelcraft-4.0.1 → modelcraft-5.0.0}/modelcraft/modelcraftem.py

@@ -25,12 +25,17 @@ class ModelCraftEm(Pipeline):
         self.report["version"] = __version__
         self.report["args"] = raw_args
         self.report["cycles"] = []
+        self.maps = {}
+        self.fmean = None
+        self.phases = None
 
     def run(self):
         print(f"# ModelCraft {__version__}", flush=True)
         os.makedirs(self.args.directory, exist_ok=self.args.overwrite_directory)
         self.start_time = time.time()
-        self._process_input_maps()
+        self._read_input_maps()
+        self._trim_input_maps()
+        self._calculate_fmean_and_phases()
         structure = self.args.model
         best_fsc = None
         cycles_without_improvement = 0
@@ -58,36 +63,52 @@ class ModelCraftEm(Pipeline):
                 break
         self.terminate("Normal")
 
-    def _process_input_maps(self):
-        maps = [read_map(path) for path in self.args.map]
-        if self.args.mask is not None:
-            mask = read_map(self.args.mask)
+    def _read_input_maps(self):
+        if self.args.half_maps:
+            self.maps["half_map1"] = read_map(self.args.half_maps[0])
+            self.maps["half_map2"] = read_map(self.args.half_maps[1])
         else:
-            mask = EmdaMapMask(maps[0]).run(self).mask
-        trimmed = ServalcatTrim(mask, maps).run(self)
-        self.args.map = trimmed.maps
-        if len(maps) == 2:
+            self.maps["single_map"] = read_map(self.args.single_map)
+        if self.args.build_map:
+            self.maps["build_map"] = read_map(self.args.build_map)
+
+    def _trim_input_maps(self):
+        if self.args.mask:
+            if self.args.mask == "auto":
+                map_for_mask = self.maps.get("half_map1", self.maps.get("single_map"))
+                mask = EmdaMapMask(map_for_mask).run(self).mask
+            else:
+                mask = read_map(self.args.mask)
+            trimmed = ServalcatTrim(mask, self.maps).run(self)
+            self.maps.update(trimmed.maps)
+
+    def _calculate_fmean_and_phases(self):
+        if self.args.build_map:
+            refmac = RefmacMapToMtz(
+                density=self.maps["build_map"],
+                resolution=self.args.resolution,
+            ).run(self)
+            fphi = refmac.fphi
+        elif self.args.half_maps:
             nemap = ServalcatNemap(
-                halfmap1=trimmed.maps[0],
-                halfmap2=trimmed.maps[1],
+                halfmap1=self.maps["half_map1"],
+                halfmap2=self.maps["half_map2"],
                 resolution=self.args.resolution,
-                mask=trimmed.mask,
             ).run(self)
-            self.args.fphi = nemap.fphi
+            fphi = nemap.fphi
         else:
             refmac = RefmacMapToMtz(
-                density=trimmed.maps[0],
+                density=self.maps["single_map"],
                 resolution=self.args.resolution,
-                blur=self.args.blur,
             ).run(self)
-            self.args.fphi = refmac.fphi
-        self.args.fmean, self.args.phases = convert_to_fsigf_and_phifom(self.args.fphi)
+            fphi = refmac.fphi
+        self.fmean, self.phases = convert_to_fsigf_and_phifom(fphi)
 
     def buccaneer(self, structure: gemmi.Structure) -> gemmi.Structure:
         result = Buccaneer(
             contents=self.args.contents,
-            fsigf=self.args.fmean,
-            phases=self.args.phases,
+            fsigf=self.fmean,
+            phases=self.phases,
             input_structure=structure,
             mr_structure=self.args.model,
             cycles=5,
@@ -99,8 +120,8 @@ class ModelCraftEm(Pipeline):
     def nautilus(self, structure: gemmi.Structure) -> gemmi.Structure:
         result = Nautilus(
             contents=self.args.contents,
-            fsigf=self.args.fmean,
-            phases=self.args.phases,
+            fsigf=self.fmean,
+            phases=self.phases,
             structure=structure,
         ).run(self)
         return result.structure
@@ -111,9 +132,9 @@ class ModelCraftEm(Pipeline):
         result = ServalcatRefine(
             structure=structure,
             resolution=self.args.resolution,
-            halfmap1=self.args.map[0] if len(self.args.map) == 2 else None,
-            halfmap2=self.args.map[1] if len(self.args.map) == 2 else None,
-            density=self.args.map[0] if len(self.args.map) == 1 else None,
+            halfmap1=self.maps.get("half_map1"),
+            halfmap2=self.maps.get("half_map2"),
+            density=self.maps.get("single_map"),
             ligand=self.args.restraints,
         ).run(self)
         return result.structure
@@ -122,8 +143,8 @@ class ModelCraftEm(Pipeline):
         result = ServalcatFsc(
             structure=structure,
             resolution=self.args.resolution,
-            halfmap1=self.args.map[0] if len(self.args.map) == 2 else None,
-            halfmap2=self.args.map[1] if len(self.args.map) == 2 else None,
-            density=self.args.map[0] if len(self.args.map) == 1 else None,
+            halfmap1=self.maps.get("half_map1"),
+            halfmap2=self.maps.get("half_map2"),
+            density=self.maps.get("single_map"),
         ).run(self)
         return result.fsc

{modelcraft-4.0.1 → modelcraft-5.0.0}/modelcraft/modelcraftxray.py

@@ -123,6 +123,8 @@ class ModelCraftXray(Pipeline):
     def run_buccaneer_and_nautilus(self):
         buccaneer = self.buccaneer()
         nautilus = self.nautilus()
+        if buccaneer is None and nautilus is None:
+            self.terminate(reason="No residues built")
         if buccaneer is None or nautilus is None:
             self.update_current_from_refmac_result(buccaneer or nautilus)
         else:
@@ -132,7 +134,7 @@ class ModelCraftXray(Pipeline):
 
     def buccaneer(self):
         if not self.args.contents.proteins:
-            return
+            return None
         result = Buccaneer(
             contents=self.args.contents,
             fsigf=self.args.fmean,
@@ -147,12 +149,14 @@ class ModelCraftXray(Pipeline):
             cycles=3 if self.cycle == 1 else 2,
             threads=self.args.threads,
         ).run(self)
+        if result.structure is None or ModelStats(result.structure).residues == 0:
+            return None
         write_mmcif(self.path("current.cif"), result.structure)
         return self.run_refmac(result.structure, cycles=10)
 
     def nautilus(self):
         if not (self.args.contents.rnas or self.args.contents.dnas):
-            return
+            return None
         result = Nautilus(
             contents=self.args.contents,
             fsigf=self.args.fmean,
@@ -161,6 +165,8 @@ class ModelCraftXray(Pipeline):
             freer=self.args.freer,
             structure=self.current_structure,
         ).run(self)
+        if result.structure is None or ModelStats(result.structure).residues == 0:
+            return None
         write_mmcif(self.path("current.cif"), result.structure)
         return self.run_refmac(result.structure, cycles=10)
 

{modelcraft-4.0.1 → modelcraft-5.0.0}/modelcraft/tests/ccpem/test_em.py

@@ -14,17 +14,18 @@ from . import (
 
 
 @in_temp_directory
-def test_3488_model():
+def test_3488_single_map():
     args = ["em"]
     args += ["--contents", sequence_path()]
-    args += ["--map", density_path()]
+    args += ["--single-map", density_path()]
     args += ["--resolution", "3.2"]
-    args += ["--blur", "10"]
     args += ["--cycles", "1"]
     args += ["--model", structure_path()]
+    args += ["--mask", "auto"]
     with pytest.raises(SystemExit):
         main(args)
-    with open(os.path.join("modelcraft", "modelcraft.json")) as report_file:
+    report_path = os.path.join("modelcraft", "modelcraft.json")
+    with open(report_path, encoding="utf-8") as report_file:
         report = json.load(report_file)
     assert report["seconds"]["total"] > 0
     assert report["final"]["fsc"] > 0.6
@@ -32,16 +33,18 @@ def test_3488_model():
 
 
 @in_temp_directory
-def test_3488_halfmaps():
+def test_3488_half_maps():
     args = ["em"]
     args += ["--contents", sequence_path()]
-    args += ["--map", halfmap1_path(), halfmap2_path()]
+    args += ["--half-maps", halfmap1_path(), halfmap2_path()]
+    args += ["--build-map", density_path()]
     args += ["--mask", mask_path()]
     args += ["--resolution", "3.2"]
     args += ["--cycles", "1"]
     with pytest.raises(SystemExit):
         main(args)
-    with open(os.path.join("modelcraft", "modelcraft.json")) as report_file:
+    report_path = os.path.join("modelcraft", "modelcraft.json")
+    with open(report_path, encoding="utf-8") as report_file:
         report = json.load(report_file)
     assert report["seconds"]["total"] > 0
     assert report["termination_reason"] == "Normal"

{modelcraft-4.0.1 → modelcraft-5.0.0}/modelcraft/tests/ccpem/test_servalcat.py

@@ -17,11 +17,13 @@ def test_servalcat_nemap():
 
 
 def test_servalcat_trim():
-    halfmap1 = read_map(halfmap1_path())
-    halfmap2 = read_map(halfmap2_path())
-    density = read_map(density_path())
+    maps = {
+        "halfmap1": read_map(halfmap1_path()),
+        "halfmap2": read_map(halfmap2_path()),
+        "density": read_map(density_path()),
+    }
     mask = read_map(mask_path())
-    trimmed = ServalcatTrim(mask, [density, halfmap1, halfmap2]).run()
+    trimmed = ServalcatTrim(mask, maps).run()
     assert len(trimmed.maps) == 3
 
 

{modelcraft-4.0.1 → modelcraft-5.0.0/modelcraft.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: modelcraft
-Version: 4.0.1
+Version: 5.0.0
 Summary: Automated model building pipeline for X-ray crystallography
 Home-page: https://github.com/paulsbond/modelcraft
 Author: Paul Bond

{modelcraft-4.0.1 → modelcraft-5.0.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as f:
 
 setuptools.setup(
     name="modelcraft",
-    version="4.0.1",
+    version="5.0.0",
     author="Paul Bond",
     author_email="paul.bond@york.ac.uk",
     description="Automated model building pipeline for X-ray crystallography",