def putXYZMeta(self, fdir, file_stdout, file_stderr, log_parser=None):
if self.files[0]:
dtype_xyz.setXYZMeta(
self,
xyzmeta.getXYZMeta(os.path.join(fdir, self.files[0]),
file_stdout, file_stderr, log_parser))
return
def run(self):
# get "extra" command line arguments
# currently args 4 and 5 are missing
'''
queueName = sys.argv[4]
nSubJobs = sys.argv[5]
'''
# temporary fix:
queueName = ""
if len(sys.argv) > 4:
if sys.argv[4] != "-":
queueName = sys.argv[4]
if self.exeType == "SGE":
nSubJobs = "0"
if len(sys.argv) > 5:
nSubJobs = sys.argv[5]
else:
nSubJobs = "4"
# end temporary fix
# Prepare morda job
# fetch input data
hkl = self.makeClass(self.input_data.data.hkl[0])
seq = self.input_data.data.seq
with open(self.morda_seq(), 'wb') as newf:
if len(seq) > 0:
for s in seq:
s1 = self.makeClass(s)
with open(s1.getFilePath(self.inputDir()), 'rb') as hf:
newf.write(hf.read())
newf.write('\n')
# prepare mtz with needed columns -- this is necessary because MoRDa does
# not have specification of mtz columns on input (labin)
labels = (hkl.dataset.Fmean.value, hkl.dataset.Fmean.sigma,
hkl.dataset.FREE)
cad_mtz = "cad.mtz"
self.open_stdin()
self.write_stdin("LABIN FILE 1 E1=%s E2=%s E3=%s\nEND\n" % labels)
self.close_stdin()
cmd = [
"HKLIN1",
os.path.join(self.inputDir(), hkl.files[0]), "HKLOUT", cad_mtz
]
self.runApp("cad", cmd)
# MORDA is running on a cluster, all output is done by morda_sge.py module;
# pass RVAPI document for morda_sge.py script
# make command-line parameters for morda_sge.py
cmd = [
"-m", "morda", "--sge" if self.exeType == "SGE" else "--mp", "-f",
cad_mtz, "-s",
self.morda_seq(), "-d",
self.reportDocumentName()
]
if self.task.parameters.sec1.contains.ALTGROUPS_CBX.value:
cmd.append("-a")
if self.task.parameters.sec1.contains.NMODELS.value:
cmd = cmd + [
"-n",
str(self.task.parameters.sec1.contains.NMODELS.value)
]
morda_out_pdb = self.getXYZOFName()
morda_out_mtz = self.getMTZOFName()
morda_out_map = self.getMapOFName()
morda_out_dmap = self.getDMapOFName()
self.storeReportDocument('{ "jobId" : "' + self.job_id + '",' +
' "logTabId" : "' + self.log_page_id() +
'",' + ' "name_xyz" : "' + morda_out_pdb +
'",' + ' "name_mtz" : "' + morda_out_mtz +
'",' + ' "name_map" : "' + morda_out_map +
'",' + ' "name_dmap" : "' + morda_out_dmap +
'",' + ' "sge_q" : "' + queueName +
'",' + ' "sge_tc" : "' + nSubJobs + '",' +
' "subjobs" : "subjobs" ' + '}')
# run morda
self.runApp("ccp4-python", cmd)
self.restoreReportDocument()
final_pdb = os.path.join(self.outputDir(), morda_out_pdb)
if os.path.isfile(final_pdb):
# solution found; firstly, check whether the space group has changed
mtzfile = os.path.join(self.outputDir(), morda_out_mtz)
sol_hkl = hkl
meta = xyzmeta.getXYZMeta(final_pdb, self.file_stdout,
self.file_stderr)
if "cryst" in meta:
sol_spg = meta["cryst"]["spaceGroup"]
spg_change = self.checkSpaceGroupChanged(sol_spg, hkl, mtzfile)
if spg_change:
mtzfile = spg_change[0]
sol_hkl = spg_change[1]
# ================================================================
# make output structure and register it
structure = self.finaliseStructure(final_pdb, self.outputFName,
sol_hkl, None, seq, 1, False)
if structure:
# update structure revision
revision = self.makeClass(self.input_data.data.revision[0])
revision.setReflectionData(sol_hkl)
revision.setStructureData(structure)
self.registerRevision(revision)
# close execution logs and quit
self.success()
return
def run(self):
# Just in case (of repeated run) remove the output xyz file. When zanuda
# succeeds, this file is created.
if os.path.isfile(self.getXYZOFName()):
os.remove(self.getXYZOFName())
# Prepare zanuda input
# fetch input data
hkl = self.makeClass(self.input_data.data.hkl[0])
xyz = self.input_data.data.struct[0]
# prepare mtz with needed columns -- this is necessary because BALBES
# does not have specification of mtz columns on input (labin)
labels = (hkl.dataset.Fmean.value, hkl.dataset.Fmean.sigma)
cad_mtz = os.path.join(self.inputDir(), "cad.mtz")
self.open_stdin()
self.write_stdin("LABIN FILE 1 E1=%s E2=%s\nEND\n" % labels)
self.close_stdin()
cmd = [
"HKLIN1",
os.path.join(self.inputDir(), hkl.files[0]), "HKLOUT", cad_mtz
]
self.runApp("cad", cmd)
# make command-line parameters for bare morda run on a SHELL-type node
cmd = [
"hklin", cad_mtz, "xyzin",
os.path.join(self.inputDir(), xyz.files[0]), "hklout",
self.getMTZOFName(), "xyzout",
self.getXYZOFName(), "tmpdir",
os.path.join(os.environ["CCP4_SCR"],
uuid.uuid4().hex)
]
if self.task.parameters.sec1.contains.AVER_CBX.value:
cmd.append("aver")
if self.task.parameters.sec1.contains.NOTWIN_CBX.value:
cmd.append("notwin")
# run zanuda
self.runApp("zanuda", cmd)
# check solution and register data
if os.path.isfile(self.getXYZOFName()):
self.unsetLogParser()
mtzfile = self.getMTZOFName()
sol_hkl = hkl
meta = xyzmeta.getXYZMeta(self.getXYZOFName(), self.file_stdout,
self.file_stderr)
if "cryst" in meta:
sol_spg = meta["cryst"]["spaceGroup"]
spg_change = self.checkSpaceGroupChanged(sol_spg, hkl, mtzfile)
if spg_change:
mtzfile = spg_change[0]
sol_hkl = spg_change[1]
else:
self.putMessage ( "<font size='+1'><b>Space Group confirmed as " +\
sol_spg + "</b></font>" )
# calculate maps for UglyMol using final mtz from temporary location
fnames = self.calcCCP4Maps(mtzfile, self.outputFName)
# register output data from temporary location (files will be moved
# to output directory by the registration procedure)
structure = self.registerStructure(self.getXYZOFName(), mtzfile,
fnames[0], fnames[1], None)
if structure:
self.putTitle("Output Structure")
#structure.addDataAssociations ( [hkl,xyz] )
structure.setRefmacLabels(sol_hkl)
structure.copySubtype(xyz)
self.putStructureWidget("structure_btn",
"Structure and electron density",
structure)
# update structure revision
revision = self.makeClass(self.input_data.data.revision[0])
revision.setReflectionData(sol_hkl)
revision.setStructureData(structure)
self.registerRevision(revision)
else:
self.putTitle("Failed to create Structure")
self.putMessage ( "This is likely to be a program bug, please " +\
"report to developer or maintainer" )
else:
self.putTitle("No Output Generated")
# close execution logs and quit
self.success()
return
def finalise(self, structure=None):
# ========================================================================
# check solution and register data
self.structure = structure
#if not structure:
self.rvrow += 20
if os.path.isfile(self.xyzout_fpath):
# get xyz metadata for checking on changed space group below
meta = xyzmeta.getXYZMeta(self.xyzout_fpath, self.file_stdout,
self.file_stderr)
# register output data
if not structure:
self.structure = self.registerStructure1(
self.xyzout_fpath, self.hklout_fpath,
self.hklout_fpath + ".map",
self.hklout_fpath + "_diff.map", None, self.outputFName)
if self.structure:
if self.native:
hkl_all = []
hkl_all += self.hkl
self.native.wtype = "native"
hkl_all.append(self.native)
else:
hkl_all = self.hkl
if self.seq:
for s in self.seq:
self.structure.addDataAssociation(s.dataId)
if self.task._type == "TaskShelxSubstr":
self.structure.setSubstrSubtype() # substructure
self.structure.setBP3Labels()
else:
self.structure.addXYZSubtype()
self.structure.setRefmacLabels(hkl_all[0])
self.structure.FP = "REFM_F"
self.structure.SigFP = "REFM_SIGF"
self.structure.addEPSubtype()
if len(hkl_all) == 1:
self.putTitle("Structure Revision")
else:
self.putTitle("Structure Revisions")
# fetch r-factors for display in job tree
fileref = os.path.join(self.reportDir(), "7-ref", "ref.log")
rfree_pattern = "R-free factor after refinement is "
rfactor_pattern = "R factor after refinement is "
rfree = 0.0
rfactor = 0.0
if os.path.isfile(fileref):
with open(fileref, 'r') as f:
for line in f:
if line.startswith(rfree_pattern):
rfree = float(line.replace(rfree_pattern, ""))
if line.startswith(rfactor_pattern):
rfactor = float(
line.replace(rfactor_pattern, ""))
if rfree > 0.0 and rfactor > 0.0:
self.generic_parser_summary["refmac"] = {
'R_factor': rfactor,
'R_free': rfree
}
# check if space group has changed
hkl_sol = None
if "cryst" in meta:
sol_spg = meta["cryst"]["spaceGroup"]
hkl_sol = self.checkSpaceGroupChanged1(sol_spg, hkl_all)
if not hkl_sol:
hkl_sol = hkl_all
self.putMessage(" ")
if len(hkl_all) > 1:
self.putMessage(
"<b><i>New structure revision name for:<br> </i></b>"
)
gridId = "revision_" + str(self.widget_no)
self.widget_no += 1
pyrvapi.rvapi_add_grid(gridId, False, self.report_page_id(),
self.rvrow, 0, 1, 1)
self.rvrow += 1
for i in range(len(hkl_all)):
# make structure revision
revision = dtype_revision.DType(-1)
revision.copy(self.revision)
revision.setReflectionData(hkl_sol[i])
revision.setStructureData(self.structure)
if len(hkl_all) == 1:
revision.makeRevDName(self.job_id, i + 1,
self.outputFName)
self.putRevisionWidget(
gridId, i,
"<b><i>New structure revision name:</i></b>",
revision)
else:
revision.makeRevDName(
self.job_id, i + 1,
self.outputFName + " (" + hkl_all[i].wtype + ")")
self.putRevisionWidget ( gridId,i,"<b><i>" +\
hkl_all[i].wtype + " dataset:</i></b>",revision )
revision.register(self.outputDataBox)
else:
self.putTitle("Failed to created output data object")
else:
self.putTitle("Output file(s) not created")
self.putMessage(" ")
self.flush()
return
def run(self):
# Prepare ample job
# fetch input data
hkl = self.makeClass ( self.input_data.data.hkl[0] )
seq = self.input_data.data.seq[0]
# make command line parameters
cmd = [ os.path.join(self.inputDir(),hkl.files[0]),
os.path.join(self.inputDir(),seq.files[0]),
"-rvapi_document",self.reportDocumentName() ]
# pass rvapi document with metadata
"""
self.storeReportDocument(
'{ "jobId" : "' + str(self.job_id).zfill(4) + '",' +
' "reportTabId" : "' + self.report_page_id() + '",'
' "logTabId" : "' + self.log_page_id() + '"'
'}'
)
"""
self.storeReportDocument ( self.log_page_id() )
#test_ample_path = os.path.join ( os.environ["CCP4"],"bin","ample_mock.py" )
# run ample
#self.runApp ( "ccp4-python",[test_ample_path] + cmd )
self.runApp ( "ample",cmd )
self.restoreReportDocument()
f = open ( 'xxx.json','w' )
f.write ( pyrvapi.rvapi_get_meta() )
f.close()
"""
{"results": [
{"info": "SHELXE trace of MR result",
"mtz": "../../../../../../opt/ample.git/ample_testing/from_existing_models/MRBUMP/search_c1_t100_r3_polyAla_mrbump/data/loc0_ALL_c1_t100_r3_polyAla/unmod/mr/phaser/build/shelxe/shelxe_phaser_loc0_ALL_c1_t100_r3_polyAla_UNMOD.mtz",
"type": "SHELXE",
"name": "c1_t100_r3_polyAla",
"pdb": "../../../../../../opt/ample.git/ample_testing/from_existing_models/MRBUMP/search_c1_t100_r3_polyAla_mrbump/data/loc0_ALL_c1_t100_r3_polyAla/unmod/mr/phaser/build/shelxe/shelxe_phaser_loc0_ALL_c1_t100_r3_polyAla_UNMOD.pdb"
},
{"info": "SHELXE trace of MR result",
"mtz": "../../../../../../opt/ample.git/ample_testing/from_existing_models/MRBUMP/search_c1_t49_r1_polyAla_mrbump/data/loc0_ALL_c1_t49_r1_polyAla/unmod/mr/phaser/build/shelxe/shelxe_phaser_loc0_ALL_c1_t49_r1_polyAla_UNMOD.mtz",
"type": "SHELXE",
"name": "c1_t49_r1_polyAla",
"pdb": "../../../../../../opt/ample.git/ample_testing/from_existing_models/MRBUMP/search_c1_t49_r1_polyAla_mrbump/data/loc0_ALL_c1_t49_r1_polyAla/unmod/mr/phaser/build/shelxe/shelxe_phaser_loc0_ALL_c1_t49_r1_polyAla_UNMOD.pdb"
},
{"info": "SHELXE trace of MR result",
"mtz": "../../../../../../opt/ample.git/ample_testing/from_existing_models/MRBUMP/search_c1_t49_r3_polyAla_mrbump/data/loc0_ALL_c1_t49_r3_polyAla/unmod/mr/phaser/build/shelxe/shelxe_phaser_loc0_ALL_c1_t49_r3_polyAla_UNMOD.mtz",
"type": "SHELXE",
"name": "c1_t49_r3_polyAla",
"pdb": "../../../../../../opt/ample.git/ample_testing/from_existing_models/MRBUMP/search_c1_t49_r3_polyAla_mrbump/data/loc0_ALL_c1_t49_r3_polyAla/unmod/mr/phaser/build/shelxe/shelxe_phaser_loc0_ALL_c1_t49_r3_polyAla_UNMOD.pdb"
}
]
}
"""
rvapi_meta = pyrvapi.rvapi_get_meta()
if rvapi_meta:
try:
ample_meta = json.loads ( rvapi_meta )
except:
self.putMessage ( "<b>Program error:</b> <i>unparseable metadata from Ample</i>" +
"<p>'" + rvapi_meta + "'" )
else:
self.putMessage ( "<b>Program error:</b> <i>no metadata from Ample</i>" )
ample_meta = {}
ample_meta["results"] = []
results = ample_meta["results"]
if len(results)<=0:
self.putTitle ( "Solution Not Found" )
else:
generic_parser_summary = None
for i in range(len(results)):
result = results[i]
self.putTitle ( "Solution " + result["name"] )
mtzfile = os.path.join ( self.reportDir(),result["mtz"] )
final_pdb = os.path.join ( self.reportDir(),result["pdb"] )
sol_hkl = hkl
meta = xyzmeta.getXYZMeta ( final_pdb,self.file_stdout,
self.file_stderr )
if "cryst" in meta:
sol_spg = meta["cryst"]["spaceGroup"]
spg_change = self.checkSpaceGroupChanged ( sol_spg,hkl,mtzfile )
if spg_change:
mtzfile = spg_change[0]
sol_hkl = spg_change[1]
# ================================================================
# make output structure and register it
structure = self.finaliseStructure ( final_pdb,self.outputFName,
sol_hkl,None,[seq],1,False,"" )
if structure:
# update structure revision
revision = self.makeClass ( self.input_data.data.revision[0] )
revision.setReflectionData ( sol_hkl )
revision.setStructureData ( structure )
self.registerRevision ( revision,i+1,"" )
if not generic_parser_summary:
generic_parser_summary = self.generic_parser_summary.copy()
else:
self.putMessage ( "Structure Data cannot be formed (probably a bug)" )
if generic_parser_summary:
self.generic_parser_summary = generic_parser_summary.copy()
# close execution logs and quit
self.success()
return