modelcraft 5.0.3__py3-none-any.whl → 6.0.0__py3-none-any.whl

modelcraft/jobs/ctruncate.py

@@ -1,7 +1,9 @@
 import dataclasses
+
 import gemmi
-from ..reflections import DataItem, write_mtz
+
 from ..job import Job
+from ..reflections import DataItem, write_mtz
 
 
 @dataclasses.dataclass

modelcraft/jobs/emda.py

@@ -1,5 +1,7 @@
 import dataclasses
+
 import gemmi
+
 from ..job import Job
 from ..maps import read_map
 

modelcraft/jobs/findwaters.py

@@ -1,5 +1,7 @@
 import dataclasses
+
 import gemmi
+
 from ..job import Job
 from ..reflections import DataItem, write_mtz
 from ..structure import read_structure, write_mmcif

modelcraft/jobs/freerflag.py

@@ -1,5 +1,7 @@
 import dataclasses
+
 import gemmi
+
 from ..job import Job
 from ..reflections import DataItem
 

modelcraft/jobs/libg.py

@@ -1,5 +1,7 @@
 import dataclasses
+
 import gemmi
+
 from ..job import Job
 from ..structure import write_mmcif
 

modelcraft/jobs/molrep.py

@@ -1,6 +1,8 @@
 import dataclasses
 import xml.etree.ElementTree as ET
+
 import gemmi
+
 from ..job import Job
 from ..reflections import DataItem, write_mtz
 from ..structure import read_structure

modelcraft/jobs/nautilus.py

@@ -1,10 +1,13 @@
 import dataclasses
 import xml.etree.ElementTree as ET
+
 import gemmi
-from ..contents import AsuContents, PolymerType
+
+from ..contents import AsuContents
 from ..job import Job
 from ..reflections import DataItem, write_mtz
-from ..structure import read_structure, remove_non_library_atoms, write_mmcif
+from ..sequence import DNA_CODES, PolymerType
+from ..structure import read_structure, write_mmcif
 
 
 @dataclasses.dataclass
@@ -16,6 +19,18 @@ class NautilusResult:
     longest_fragment: int
     seconds: float
 
+    def __init__(self, job: Job):
+        job._check_files_exist("xmlout.xml", "xyzout.cif")
+        xml = ET.parse(job._path("xmlout.xml")).getroot()
+        structure = read_structure(job._path("xyzout.cif"))
+        _deoxyfy(structure)
+        self.structure = structure
+        self.fragments_built = int(xml.find("Final/FragmentsBuilt").text)
+        self.residues_built = int(xml.find("Final/ResiduesBuilt").text)
+        self.residues_sequenced = int(xml.find("Final/ResiduesSequenced").text)
+        self.longest_fragment = int(xml.find("Final/ResiduesLongestFragment").text)
+        self.seconds = job._seconds
+
 
 class Nautilus(Job):
     def __init__(
@@ -63,15 +78,14 @@ class Nautilus(Job):
         self._args += ["-xmlout", "xmlout.xml"]
 
     def _result(self) -> NautilusResult:
-        self._check_files_exist("xmlout.xml", "xyzout.cif")
-        xml = ET.parse(self._path("xmlout.xml")).getroot()
-        structure = read_structure(self._path("xyzout.cif"))
-        remove_non_library_atoms(structure)
-        return NautilusResult(
-            structure=structure,
-            fragments_built=int(xml.find("Final/FragmentsBuilt").text),
-            residues_built=int(xml.find("Final/ResiduesBuilt").text),
-            residues_sequenced=int(xml.find("Final/ResiduesSequenced").text),
-            longest_fragment=int(xml.find("Final/ResiduesLongestFragment").text),
-            seconds=self._seconds,
-        )
+        return NautilusResult(self)
+
+
+def _deoxyfy(structure: gemmi.Structure) -> None:
+    dna_codes = set(DNA_CODES.values())
+    for chain in structure[0]:
+        for residue in chain:
+            if residue.name in dna_codes and "O2'" in residue:
+                for i, atom in reversed(list(enumerate(residue))):
+                    if atom.name == "O2'":
+                        del residue[i]

modelcraft/jobs/nucleofind.py

@@ -0,0 +1,88 @@
+import dataclasses
+
+import gemmi
+
+from ..contents import AsuContents, PolymerType
+from ..job import Job
+from ..jobs.nautilus import NautilusResult
+from ..reflections import DataItem, write_mtz
+from ..structure import write_mmcif
+
+
+@dataclasses.dataclass
+class NucleoFindPrediction:
+    phosphate: gemmi.Ccp4Map
+    sugar: gemmi.Ccp4Map
+    base: gemmi.Ccp4Map
+    seconds: float
+
+
+class NucleoFindPredict(Job):
+    def __init__(self, fphi: DataItem):
+        super().__init__("nucleofind")
+        self.fphi = fphi
+
+    def _setup(self) -> None:
+        write_mtz(self._path("hklin.mtz"), [self.fphi])
+        self._args += ["--input", "hklin.mtz"]
+        self._args += ["--amplitude", self.fphi.label(0)]
+        self._args += ["--phase", self.fphi.label(1)]
+        self._args += ["--model", "core"]
+        self._args += ["--gpu"]
+        self._args += ["--nthreads", "1"]
+        self._args += ["--output", "."]
+
+    def _result(self) -> NucleoFindPrediction:
+        self._check_files_exist("nucleofind-phosphate.map")
+        self._check_files_exist("nucleofind-sugar.map")
+        self._check_files_exist("nucleofind-base.map")
+
+        return NucleoFindPrediction(
+            phosphate=gemmi.read_ccp4_map(self._path("nucleofind-phosphate.map")),
+            sugar=gemmi.read_ccp4_map(self._path("nucleofind-sugar.map")),
+            base=gemmi.read_ccp4_map(self._path("nucleofind-base.map")),
+            seconds=self._seconds,
+        )
+
+
+class NucleoFindBuild(Job):
+    def __init__(
+        self,
+        contents: AsuContents,
+        fphi: DataItem,
+        prediction: NucleoFindPrediction,
+        structure: gemmi.Structure = None,
+        em: bool = False,
+    ):
+        super().__init__("nucleofind-build")
+        self.contents = contents
+        self.fphi = fphi
+        self.prediction = prediction
+        self.structure = structure
+        self.em = em
+
+    def _setup(self) -> None:
+        types = [PolymerType.RNA, PolymerType.DNA]
+        self.contents.write_sequence_file(self._path("seqin.seq"), types)
+        self._args += ["--seqin", "seqin.seq"]
+        write_mtz(self._path("hklin.mtz"), [self.fphi])
+        self._args += ["--mtzin", "hklin.mtz"]
+        self._args += ["--colin-fc", self.fphi.label()]
+        self.prediction.phosphate.write_ccp4_map(self._path("phosin.map"))
+        self.prediction.sugar.write_ccp4_map(self._path("sugarin.map"))
+        self.prediction.base.write_ccp4_map(self._path("basein.map"))
+        self._args += ["--phosin", "phosin.map"]
+        self._args += ["--sugarin", "sugarin.map"]
+        self._args += ["--basein", "basein.map"]
+        if self.structure is not None:
+            write_mmcif(self._path("xyzin.cif"), self.structure)
+            self._args += ["--pdbin", "xyzin.cif"]
+        self._args += ["--cycles", "3"]
+        self._args += ["--pdbout", "xyzout.cif"]
+        self._args += ["--xmlout", "xmlout.xml"]
+        self._args += ["--remove_clashing_protein"]
+        if self.em:
+            self._args += ["--em"]
+
+    def _result(self) -> NautilusResult:
+        return NautilusResult(self)

modelcraft/jobs/parrot.py

@@ -1,7 +1,10 @@
 import dataclasses
+
 import gemmi
+
 from ..contents import AsuContents
 from ..job import Job
+from ..monlib import MonLib
 from ..reflections import DataItem, write_mtz
 from ..solvent import solvent_fraction
 from ..structure import write_mmcif
@@ -23,12 +26,14 @@ class Parrot(Job):
         phases: DataItem,
         fphi: DataItem = None,
         structure: gemmi.Structure = None,
+        monlib: MonLib = None,
     ):
         super().__init__("cparrot")
         self.contents = contents
         self.fsigf = fsigf
         self.freer = freer
         self.phases = phases
+        self.monlib = monlib
         self.fphi = fphi
         self.structure = structure
 
@@ -49,8 +54,14 @@ class Parrot(Job):
         if self.structure is not None:
             write_mmcif(self._path("xyzin.cif"), self.structure)
             self._args += ["-pdbin-mr", "xyzin.cif"]
-        solvent_content = solvent_fraction(self.contents, self.fsigf)
-        self._args += ["-solvent-content", "%.3f" % solvent_content]
+        solvent_content = solvent_fraction(
+            contents=self.contents,
+            cell=self.fsigf.cell,
+            spacegroup=self.fsigf.spacegroup,
+            resolution=self.fsigf.resolution_high(),
+            monlib=self.monlib,
+        )
+        self._args += ["-solvent-content", f"{solvent_content:.3f}"]
         self._args += ["-cycles", "5"]
         self._args += ["-anisotropy-correction"]
         self._args += ["-mtzout", "hklout.mtz"]

modelcraft/jobs/phasematch.py

@@ -1,4 +1,5 @@
 import dataclasses
+
 from ..job import Job
 from ..reflections import DataItem, write_mtz
 
@@ -35,7 +36,7 @@ class PhaseMatch(Job):
     def _result(self) -> PhaseMatchResult:
         self._check_files_exist("hklout.mtz")
         path = self._path("stdout.txt")
-        with open(path) as stream:
+        with open(path, encoding="utf-8") as stream:
             for line in stream:
                 if line[:19] == "Overall statistics:":
                     keys = next(stream).split()

modelcraft/jobs/refmac.py

@@ -1,7 +1,9 @@
 import dataclasses
 import shutil
 import xml.etree.ElementTree as ET
+
 import gemmi
+
 from ..job import Job
 from ..reflections import DataItem, write_mtz
 from ..structure import read_structure, write_mmcif
@@ -98,7 +100,7 @@ class Refmac(Job):
             abcd=DataItem(mtz, "HLACOMB,HLBCOMB,HLCCOMB,HLDCOMB"),
             fphi_best=DataItem(mtz, "FWT,PHWT"),
             fphi_diff=DataItem(mtz, "DELFWT,PHDELWT"),
-            fphi_calc=DataItem(mtz, "FC_ALL_LS,PHIC_ALL_LS"),
+            fphi_calc=DataItem(mtz, "FC_ALL,PHIC_ALL"),
             rwork=float(rworks[-1].text),
             rfree=float(rfrees[-1].text),
             fsc=float(fscs[-1].text),

modelcraft/jobs/servalcat.py

@@ -1,12 +1,46 @@
 import dataclasses
 import shutil
+
 import gemmi
+
 from ..job import Job
 from ..maps import read_map
-from ..reflections import DataItem
+from ..reflections import DataItem, write_mtz
 from ..structure import read_structure, write_mmcif
 
 
+@dataclasses.dataclass
+class ServalcatFwResult:
+    fmean: DataItem
+    fanom: DataItem
+    imean: DataItem
+    seconds: float
+
+
+class ServalcatFw(Job):
+    def __init__(self, observations: DataItem):
+        super().__init__("servalcat")
+        self.observations = observations
+
+    def _setup(self) -> None:
+        write_mtz(self._path("hklin.mtz"), [self.observations])
+        self._args += ["fw", "--hklin", "hklin.mtz", "-o", "output"]
+
+    def _result(self) -> ServalcatFwResult:
+        self._check_files_exist("output.mtz")
+        mtz = gemmi.read_mtz_file(self._path("output.mtz"))
+        result = ServalcatFwResult(
+            fmean=DataItem(mtz, "F,SIGF"),
+            fanom=None,
+            imean=None,
+            seconds=self._seconds,
+        )
+        if self.observations.types == "KMKM":
+            result.fanom = DataItem(mtz, "F(+),SIGF(+),F(-),SIGF(-)")
+            result.imean = DataItem(mtz, "I,SIGI")
+        return result
+
+
 @dataclasses.dataclass
 class ServalcatNemapResult:
     fphi: DataItem
@@ -190,7 +224,7 @@ class ServalcatFsc(Job):
     def _result(self) -> ServalcatFscResult:
         self._check_files_exist("fsc.dat")
         fsc = None
-        with open(self._path("fsc.dat")) as text:
+        with open(self._path("fsc.dat"), encoding="utf-8") as text:
             for line in text:
                 if line.startswith("# FSCaverage of fsc_FC_full ="):
                     fsc = float(line.strip().split()[-1])

modelcraft/jobs/sheetbend.py

@@ -1,5 +1,7 @@
 import dataclasses
+
 import gemmi
+
 from ..job import Job
 from ..reflections import DataItem, write_mtz
 from ..structure import read_structure, write_mmcif

modelcraft/modelcraftem.py

@@ -1,10 +1,14 @@
 import os
+import shutil
 import time
+
 import gemmi
+
 from . import __version__
 from .jobs.buccaneer import Buccaneer
 from .jobs.emda import EmdaMapMask
 from .jobs.nautilus import Nautilus
+from .jobs.nucleofind import NucleoFindBuild, NucleoFindPredict
 from .jobs.refmac import RefmacMapToMtz
 from .jobs.servalcat import ServalcatFsc, ServalcatNemap, ServalcatRefine, ServalcatTrim
 from .maps import read_map
@@ -28,24 +32,36 @@ class ModelCraftEm(Pipeline):
         self.maps = {}
         self.fmean = None
         self.phases = None
+        self.fphi = None
+        self.nucleofind_prediction = 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._read_input_maps()
+        original_map_centre = self.map_centre()
         self._trim_input_maps()
         self._calculate_fmean_and_phases()
         structure = self.args.model
         best_fsc = None
         cycles_without_improvement = 0
+        build_nucleic = self.args.contents.rnas or self.args.contents.dnas
+        if build_nucleic and shutil.which("nucleofind"):
+            try:
+                self.nucleofind_prediction = NucleoFindPredict(self.fphi).run(self)
+            except FileNotFoundError:
+                print("Warning: nucleofind prediction failed", flush=True)
         for cycle in range(1, self.args.cycles + 1):
             print(f"\n## Cycle {cycle}\n", flush=True)
             if self.args.contents.proteins:
                 structure = self.buccaneer(structure)
                 structure = self.servalcat_refine(structure)
-            if self.args.contents.rnas or self.args.contents.dnas:
-                structure = self.nautilus(structure)
+            if build_nucleic:
+                if self.nucleofind_prediction is None:
+                    structure = self.nautilus(structure)
+                else:
+                    structure = self.nucleofind(structure)
                 structure = self.servalcat_refine(structure)
             model_stats = ModelStats(structure)
             fsc = self.servalcat_fsc(structure)
@@ -54,6 +70,7 @@ class ModelCraftEm(Pipeline):
             if best_fsc is None or fsc > best_fsc:
                 best_fsc = fsc
                 cycles_without_improvement = 0
+                self.shift(structure, original_map_centre)
                 write_mmcif(self.path("modelcraft.cif"), structure)
                 self.report["final"] = stats
             else:
@@ -88,21 +105,21 @@ class ModelCraftEm(Pipeline):
                 density=self.maps["build_map"],
                 resolution=self.args.resolution,
             ).run(self)
-            fphi = refmac.fphi
+            self.fphi = refmac.fphi
         elif self.args.half_maps:
             nemap = ServalcatNemap(
                 halfmap1=self.maps["half_map1"],
                 halfmap2=self.maps["half_map2"],
                 resolution=self.args.resolution,
             ).run(self)
-            fphi = nemap.fphi
+            self.fphi = nemap.fphi
         else:
             refmac = RefmacMapToMtz(
                 density=self.maps["single_map"],
                 resolution=self.args.resolution,
             ).run(self)
-            fphi = refmac.fphi
-        self.fmean, self.phases = convert_to_fsigf_and_phifom(fphi)
+            self.fphi = refmac.fphi
+        self.fmean, self.phases = convert_to_fsigf_and_phifom(self.fphi)
 
     def buccaneer(self, structure: gemmi.Structure) -> gemmi.Structure:
         result = Buccaneer(
@@ -126,6 +143,16 @@ class ModelCraftEm(Pipeline):
         ).run(self)
         return result.structure
 
+    def nucleofind(self, structure: gemmi.Structure) -> gemmi.Structure:
+        result = NucleoFindBuild(
+            contents=self.args.contents,
+            fphi=self.fphi,
+            prediction=self.nucleofind_prediction,
+            structure=structure,
+            em=True,
+        ).run(self)
+        return result.structure
+
     def servalcat_refine(self, structure: gemmi.Structure) -> gemmi.Structure:
         if ModelStats(structure).residues == 0:
             self.terminate(reason="No residues to refine")
@@ -148,3 +175,19 @@ class ModelCraftEm(Pipeline):
             density=self.maps.get("single_map"),
         ).run(self)
         return result.fsc
+
+    def map_centre(self):
+        first_map = next(iter(self.maps.values()))
+        fractional = gemmi.Fractional(0.5, 0.5, 0.5)
+        return first_map.grid.unit_cell.orthogonalize(fractional)
+
+    def shift(self, structure: gemmi.Structure, original_map_centre: gemmi.Position):
+        model_centre = structure[0].calculate_center_of_mass()
+        diff = original_map_centre - model_centre
+        shift = gemmi.Vec3(
+            round(diff[0] / structure.cell.a) * structure.cell.a,
+            round(diff[1] / structure.cell.b) * structure.cell.b,
+            round(diff[2] / structure.cell.c) * structure.cell.c,
+        )
+        transform = gemmi.Transform(gemmi.Mat33(), shift)
+        structure[0].transform_pos_and_adp(transform)