servalcat 0.4.72__cp312-cp312-macosx_11_0_arm64.whl → 0.4.88__cp312-cp312-macosx_11_0_arm64.whl

servalcat/spa/fofc.py

@@ -377,6 +377,17 @@ def write_coot_script(py_out, model_file, mtz_file, contour_fo=1.2, contour_fofc
                 ofs.write("add_molecular_symmetry(imol, {})\n".format(",".join(str(x) for x in v)))
 # write_coot_script()
 
+def write_chimerax_script(cxc_out, model_file, fo_mrc_file, fofc_mrc_file):
+    with open(cxc_out, "w") as ofs:
+        ofs.write('open {}\n'.format(model_file))
+        ofs.write('open {}\n'.format(fo_mrc_file))
+        ofs.write('open {}\n'.format(fofc_mrc_file))
+        ofs.write('volume #3 level 4 level -4 color #00FF00 color #FF0000 squaremesh false cap false style mesh meshlighting false\n')
+        ofs.write('isolde start\n')
+        ofs.write('clipper associate #2 toModel #1\n')
+        ofs.write('clipper associate #3 toModel #1\n')
+# write_chimerax_script()
+
 def main(args):
     if not args.halfmaps and not args.map:
         raise SystemExit("Error: give --halfmaps or --map")

servalcat/spa/fsc.py

@@ -36,6 +36,8 @@ def add_arguments(parser):
     parser.add_argument('--mask_soft_edge',
                         type=float, default=0,
                         help='Add soft edge to model mask.')
+    parser.add_argument('--mask_model', action='store_true',
+                        help='Apply mask to model density')
     parser.add_argument("--b_before_mask", type=float,
                         help="when model-based mask is used: sharpening B value for sharpen-mask-unsharpen procedure. By default it is determined automatically.")
     parser.add_argument('--no_sharpen_before_mask', action='store_true',
@@ -340,7 +342,7 @@ def main(args):
         labs_fc.append("FC")
         hkldata.df[labs_fc[-1]] = utils.model.calc_fc_fft(st_expanded, args.resolution - 1e-6, source="electron",
                                                           miller_array=hkldata.miller_array())
-        if mask is not None:
+        if args.mask_model and mask is not None:
             if args.b_before_mask is None:
                 normalizer = 1.
             else:

servalcat/spa/run_refmac.py

@@ -311,6 +311,12 @@ def calc_fofc(st, st_expanded, maps, monlib, model_format, args, diffmap_prefix=
                                contour_fo=None if mask is None else 1.2,
                                contour_fofc=None if mask is None else 3.0,
                                ncs_ops=st.ncs)
+
+    # Create ChimeraX script
+    spa.fofc.write_chimerax_script(cxc_out="{}_chimerax.cxc".format(args.output_prefix),
+                                   model_file="{}.mmcif".format(args.output_prefix), # ChimeraX handles mmcif just fine
+                                   fo_mrc_file="{}_normalized_fo.mrc".format(diffmap_prefix),
+                                   fofc_mrc_file="{}_normalized_fofc.mrc".format(diffmap_prefix))
 # calc_fofc()
 
 def write_final_summary(st, refmac_summary, fscavg_text, output_prefix, is_mask_given):
@@ -356,6 +362,9 @@ Weight used: {final_weight}
 Open refined model and diffmap.mtz with COOT:
 coot --script {prefix}_coot.py
 
+Open refined model, map and difference map with ChimeraX/ISOLDE:
+chimerax {prefix}_chimerax.cxc
+
 {map_peaks_msg}
 =============================================================================
 """.format(rmsbond=refmac_summary["cycles"][-1].get("rms_bond", "???"),
@@ -681,8 +690,9 @@ def check_args(args):
     if args.keyword_file:
         args.keyword_file = sum(args.keyword_file, [])
         for f in args.keyword_file:
+            if not os.path.exists(f):
+                raise SystemExit(f"Error: keyword file was not found: {f}")
             logger.writeln("Keyword file: {}".format(f))
-            assert os.path.exists(f)
     else:
         args.keyword_file = []
 

servalcat/utils/fileio.py

@@ -86,6 +86,7 @@ def write_mmcif(st, cif_out, cif_ref=None):
         groups.entity_poly_seq = True
         groups.cis = True
         groups.conn = True
+        groups.software = True
         # FIXME is this all? 
         try:
             doc = read_cif_safe(cif_ref)
@@ -306,7 +307,7 @@ def read_cif_safe(cif_in):
     return doc
 # read_cif_safe()
 
-def read_structure(xyz_in, assign_het_flags=True):
+def read_structure(xyz_in, assign_het_flags=True, merge_chain_parts=True):
     spext = splitext(xyz_in)
     st = None
     if spext[1].lower() in (".pdb", ".ent"):
@@ -354,6 +355,8 @@ def read_structure(xyz_in, assign_het_flags=True):
         logger.writeln("")
     if assign_het_flags:
         st.assign_het_flags()
+    if merge_chain_parts:
+        st.merge_chain_parts()
     return st
 # read_structure()
 
@@ -712,7 +715,7 @@ def read_small_molecule_files(files):
                 logger.writeln("reflection data read from: {}".format(filename))
             elif b.find_loop("_refln_index_h"):
                 mtz = read_smcif_hkl(filename, st.cell, st.find_spacegroup())
-        except RuntimeError: # not a cif file
+        except ValueError: # not a cif file
             if ext == ".hkl":
                 mtz = read_shelx_hkl(st.cell, st.find_spacegroup(), hklf, file_in=filename)
                 logger.writeln("reflection data read from: {}".format(filename))

servalcat/utils/hkl.py

@@ -114,6 +114,12 @@ def hkldata_from_mtz(mtz, labels, newlabels=None, require_types=None):
     return HklData(mtz.cell, mtz.spacegroup, df)
 # hkldata_from_mtz()
 
+def df_from_twin_data(twin_data, fc_labs):
+    df = pandas.DataFrame(data=twin_data.asu,
+                          columns=["H","K","L"])
+    df[fc_labs] = twin_data.f_calc
+    return df
+
 def blur_mtz(mtz, B):
     # modify given mtz object
     
@@ -190,6 +196,17 @@ def decide_n_bins(n_per_bin, s_array, power=2, min_bins=1, max_bins=50):
     return n_bins
 # decide_n_bins()
 
+def fft_map(cell, sg, miller_array, data, grid_size=None, sample_rate=3):
+    if data is not None:
+        data = data.astype(numpy.complex64) # we may want to keep complex128?
+    asu = gemmi.ComplexAsuData(cell, sg, miller_array, data)
+    if grid_size is None:
+        ma = asu.transform_f_phi_to_map(sample_rate=sample_rate, exact_size=(0, 0, 0)) # half_l=True
+    else:
+        ma = gemmi.transform_f_phi_grid_to_map(asu.get_f_phi_on_grid(grid_size)) # half_l=False
+    return ma
+# fft_map()
+
 class HklData:
     def __init__(self, cell, sg, df=None, binned_df=None):
         self.cell = cell
@@ -514,14 +531,9 @@ class HklData:
     # as_asu_data()
 
     def fft_map(self, label=None, data=None, grid_size=None, sample_rate=3):
-        if data is not None: data = data.astype(numpy.complex64) # we may want to keep complex128?
-        asu = self.as_asu_data(label=label, data=data)
-        if grid_size is None:
-            ma = asu.transform_f_phi_to_map(sample_rate=sample_rate, exact_size=(0, 0, 0)) # half_l=True
-        else:
-            ma = gemmi.transform_f_phi_grid_to_map(asu.get_f_phi_on_grid(grid_size)) # half_l=False
-            
-        return ma
+        if data is None:
+            data = self.df[label]
+        return fft_map(self.cell, self.sg, self.miller_array(), data, grid_size, sample_rate)
     # fft_map()
 
     def d_eff(self, label):

servalcat/utils/model.py

@@ -389,6 +389,19 @@ def cra_to_atomaddress(cra):
     return aa
 # cra_to_atomaddress()
 
+def check_occupancies(st, raise_error=False):
+    bad = []
+    for cra in st[0].all():
+        if not 0 <= cra.atom.occ <= 1 + 1e-6:
+            bad.append(cra)
+    if bad:
+        logger.writeln("Bad occupancies:")
+        for cra in bad:
+            logger.writeln(f" {cra} occ= {cra.atom.occ:.4f}")
+        if raise_error:
+            raise RuntimeError("Please check your model and fix bad occupancies")
+# check_occupancies()
+
 def find_special_positions(st, special_pos_threshold=0.2, fix_occ=True, fix_pos=True, fix_adp=True):
     ns = gemmi.NeighborSearch(st[0], st.cell, 3).populate()
     cs = gemmi.ContactSearch(special_pos_threshold * 2)

servalcat/utils/refmac.py

@@ -148,6 +148,8 @@ class FixForRefmac:
         self.MAXNUM = 9999
         self.fixes = []
         self.resn_old_new = []
+        self.res_labels = []
+        self.entities = None
         
     def fix_before_topology(self, st, topo, fix_microheterogeneity=True, fix_resimax=True, fix_nonpolymer=True, add_gaps=False):
         self.chainids = set(chain.name for chain in st[0])
@@ -385,6 +387,14 @@ class FixForRefmac:
         st.shorten_ccd_codes()
         self.resn_old_new = [x for x in st.shortened_ccd_codes]
 
+    def store_res_labels(self, st):
+        self.res_labels = []
+        self.entities = gemmi.EntityList(st.entities)
+        for chain in st[0]:
+            self.res_labels.append([])
+            for res in chain:
+                self.res_labels[-1].append((res.subchain, res.entity_id, res.label_seq))
+        
     def fix_model(self, st, changedict):
         chain_newid = set()
         for chain in st[0]:
@@ -411,6 +421,15 @@ class FixForRefmac:
             st.shortened_ccd_codes = self.resn_old_new
             st.restore_full_ccd_codes()
 
+        if self.res_labels:
+            st.entities = self.entities
+            #print(f"debug {len(self.res_labels)}")
+            #print(f"debug {[x.name for x in st[0]]}")
+            assert len(self.res_labels) == len(st[0])
+            for ic, chain in enumerate(st[0]):
+                assert len(self.res_labels[ic]) == len(chain)
+                for ir, res in enumerate(chain):
+                    res.subchain, res.entity_id, res.label_seq = self.res_labels[ic][ir]
 
 class Refmac:
     def __init__(self, **kwargs):

servalcat/utils/restraints.py

@@ -521,7 +521,7 @@ def find_and_fix_links(st, monlib, bond_margin=1.3, find_metal_links=True, add_f
                                                 cra2.residue, cra2.atom.name, cra2.atom.altloc)
             if link:
                 con.link_id = link.id
-            elif find_metal_links and con.type == gemmi.ConnectionType.MetalC:
+            elif con.type == gemmi.ConnectionType.MetalC:
                 logger.writeln(" Metal link will be added: {} dist= {:.2f}".format(atoms_str, dist))
                 if cra2.atom.element.is_metal:
                     inv = True # make metal first
@@ -587,6 +587,8 @@ def find_and_fix_links(st, monlib, bond_margin=1.3, find_metal_links=True, add_f
             logger.writeln(" {}Metal link found: {} dist= {:.2f} max_ideal= {:.2f}".format("*" if will_be_added else " ",
                                                                                            atoms_str,
                                                                                            r.dist, max_ideal))
+        else:
+            continue
         n_found += 1
         if not will_be_added: continue
         con = gemmi.Connection()
@@ -653,12 +655,7 @@ def prepare_ncs_restraints(st, rms_loc_nlen=5, min_nalign=10, max_rms_loc=2.0):
                       gemmi.PolymerType.Dna, gemmi.PolymerType.Rna, gemmi.PolymerType.DnaRnaHybrid):
             polymers.setdefault(p_type, []).append((chain, rs))
 
-    scoring = gemmi.AlignmentScoring()
-    scoring.match = 0
-    scoring.mismatch = -1
-    scoring.gapo = 0
-    scoring.gape = -1
-            
+    scoring = gemmi.AlignmentScoring("p") # AlignmentScoring::partial_model
     al_res = []
     ncslist = ext.NcsList()
     for pt in polymers:
@@ -668,12 +665,25 @@ def prepare_ncs_restraints(st, rms_loc_nlen=5, min_nalign=10, max_rms_loc=2.0):
             q = [x.name for x in pols[i][1]]
             for j in range(i+1, len(pols)):
                 al = gemmi.align_sequence_to_polymer(q, pols[j][1], pt, scoring)
+                if 0: # debug
+                    wrap_width = 100
+                    logger.writeln(f"seq1: {pols[i][0].name} {pols[i][1][0].seqid}..{pols[i][1][-1].seqid}")
+                    logger.writeln(f"seq2: {pols[j][0].name} {pols[j][1][0].seqid}..{pols[j][1][-1].seqid}")
+                    logger.writeln(f"match_count: {al.match_count}")
+                    s1 = gemmi.one_letter_code(q)
+                    p_seq = gemmi.one_letter_code(pols[j][1].extract_sequence())
+                    p1, p2 = al.add_gaps(s1, 1), al.add_gaps(p_seq, 2)
+                    for k in range(0, len(p1), wrap_width):
+                        logger.writeln(" seq.  {}".format(p1[k:k+wrap_width]))
+                        logger.writeln("       {}".format(al.match_string[k:k+wrap_width]))
+                        logger.writeln(" model {}\n".format(p2[k:k+wrap_width]))
                 if al.match_count < min_nalign: continue
                 su = gemmi.calculate_superposition(pols[i][1], pols[j][1], pt, gemmi.SupSelect.All)
                 obj = ext.NcsList.Ncs(al, pols[i][1], pols[j][1])
                 obj.calculate_local_rms(rms_loc_nlen)
-                if len(obj.local_rms) == 0: continue
-                ave_local_rms = numpy.mean(obj.local_rms)
+                if len(obj.local_rms) == 0 or numpy.all(numpy.isnan(obj.local_rms)):
+                    continue
+                ave_local_rms = numpy.nanmean(obj.local_rms)
                 if ave_local_rms > max_rms_loc: continue
                 ncslist.ncss.append(obj)
                 al_res.append({"chain_1": "{} ({}..{})".format(pols[i][0].name, pols[i][1][0].seqid, pols[i][1][-1].seqid),

servalcat/xtal/french_wilson.py

@@ -174,52 +174,55 @@ def ll_shift_B(x, ssqmat, hkldata, adpdirs):
     g, H = numpy.dot(g, adpdirs.T), numpy.dot(adpdirs, numpy.dot(H, adpdirs.T))
     return -numpy.dot(g, numpy.linalg.pinv(H))
 
+def expected_F_from_int(Io, sigo, k_ani, eps, c, S):
+    to = Io / sigo - sigo / c / k_ani**2 / S / eps
+    k_num = numpy.where(c == 1,  0.5, 0.)
+    F = numpy.sqrt(sigo) * ext.integ_J_ratio(k_num, k_num - 0.5, False, to, 0., 1., c,
+                                             integr.exp2_threshold, integr.h, integr.N, integr.ewmax)
+    Fsq = sigo * ext.integ_J_ratio(k_num + 0.5, k_num - 0.5, False, to, 0., 1., c,
+                                   integr.exp2_threshold, integr.h, integr.N, integr.ewmax)
+    varF = Fsq - F**2
+    return F, numpy.sqrt(varF)
+
 def french_wilson(hkldata, B_aniso, labout=None):
     if labout is None: labout = ["F", "SIGF"]
-    hkldata.df[labout[0]] = numpy.nan
-    hkldata.df[labout[1]] = numpy.nan
-    hkldata.df["to1"] = numpy.nan
     k_ani = hkldata.debye_waller_factors(b_cart=B_aniso)
-    
+    has_ano = "I(+)" in hkldata.df and "I(-)" in hkldata.df
+    if has_ano:
+        ano_data = hkldata.df[["I(+)", "SIGI(+)", "I(-)", "SIGI(-)"]].to_numpy()
+        if len(labout) == 2:
+            labout += [f"{labout[0]}(+)", f"{labout[1]}(+)", f"{labout[0]}(-)", f"{labout[1]}(-)"]
+    hkldata.df[labout] = numpy.nan
     for i_bin, idxes in hkldata.binned():
         S = hkldata.binned_df.S[i_bin]
         c = hkldata.df.centric.to_numpy()[idxes] + 1 # 1 for acentric, 2 for centric
         Io = hkldata.df.I.to_numpy()[idxes]
         sigo = hkldata.df.SIGI.to_numpy()[idxes]
         eps = hkldata.df.epsilon.to_numpy()[idxes]
-        to = Io / sigo - sigo / c / k_ani[idxes]**2 / S / eps
-        k_num = numpy.where(c == 1,  0.5, 0.)
-        F = numpy.sqrt(sigo) * ext.integ_J_ratio(k_num, k_num - 0.5, False, to, 0., 1., c,
-                                                 integr.exp2_threshold, integr.h, integr.N, integr.ewmax)
-        Fsq = sigo * ext.integ_J_ratio(k_num + 0.5, k_num - 0.5, False, to, 0., 1., c,
-                                       integr.exp2_threshold, integr.h, integr.N, integr.ewmax)
-        varF = Fsq - F**2
+        F, sigF = expected_F_from_int(Io, sigo, k_ani[idxes], eps, c, S)
         hkldata.df.loc[idxes, labout[0]] = F
-        hkldata.df.loc[idxes, labout[1]] = numpy.sqrt(varF)
-        hkldata.df.loc[idxes, "to1"] = to
+        hkldata.df.loc[idxes, labout[1]] = sigF
+        if has_ano:
+            Fp, sigFp = expected_F_from_int(ano_data[idxes,0], ano_data[idxes,1], k_ani[idxes], eps, c, S)
+            Fm, sigFm = expected_F_from_int(ano_data[idxes,2], ano_data[idxes,3], k_ani[idxes], eps, c, S)
+            hkldata.df.loc[idxes, labout[2]] = Fp
+            hkldata.df.loc[idxes, labout[3]] = sigFp
+            hkldata.df.loc[idxes, labout[4]] = Fm
+            hkldata.df.loc[idxes, labout[5]] = sigFm
 
 def main(args):
     if not args.output_prefix:
         args.output_prefix = utils.fileio.splitext(os.path.basename(args.hklin))[0] + "_fw"
+    try:
+        mtz = utils.fileio.read_mmhkl(args.hklin, cif_index=args.hklin_index)
+    except RuntimeError as e:
+        raise SystemExit("Error: {}".format(e))
     if not args.labin:
-        try:
-            mtz = utils.fileio.read_mmhkl(args.hklin, cif_index=args.hklin_index)
-        except RuntimeError as e:
-            raise SystemExit("Error: {}".format(e))
-        dlabs = utils.hkl.mtz_find_data_columns(mtz)
-        if dlabs["J"]:
-            labin = dlabs["J"][0]
-        else:
-            raise SystemExit("Intensity not found from mtz")
-        flabs = utils.hkl.mtz_find_free_columns(mtz)
-        if flabs:
-            labin += [flabs[0]]
-        logger.writeln("MTZ columns automatically selected: {}".format(labin))
+        labin = sigmaa.decide_mtz_labels(mtz, require=("K", "J"))
     else:
         labin = args.labin.split(",")
-
     try:
-        hkldata, _, _, _, _ = sigmaa.process_input(hklin=args.hklin,
+        hkldata, _, _, _, _ = sigmaa.process_input(hklin=mtz,
                                                    labin=labin,
                                                    n_bins=args.nbins,
                                                    free=None,
@@ -237,6 +240,9 @@ def main(args):
     mtz_out = args.output_prefix+".mtz"
     lab_out = ["F", "SIGF", "I", "SIGI"]
     labo_types = {"F":"F", "SIGF":"Q", "I":"J", "SIGI":"Q"}
+    if "I(+)" in hkldata.df and "I(-)" in hkldata.df:
+        lab_out += ["F(+)", "SIGF(+)", "F(-)", "SIGF(-)"]
+        labo_types.update({"F(+)":"G", "SIGF(+)":"L", "F(-)":"G", "SIGF(-)":"L"})
     if len(labin) == 3:
         lab_out.append("FREE")
         labo_types[lab_out[-1]] = "I"