def createDataInputCharacterisationFromDataSets(self,
_pyListXSDataCCP4iDataSet):
"""
This method takes as input a list of ccp4i data sets. Each data set can contain several
paths to image files. It runs the EDPluginControlSubWedgeAssemble plugin to read the
experimental information from the image headers and then creates a single XSDataInputCharacterisation object.
"""
EDVerbose.DEBUG(
"EDPluginControlCCP4iv1_1.createDataInputCharacterisationFromDataSets"
)
xsDataInputCharacterisation = None
# We might have to run the plugin several times
edActionCluster = EDActionCluster()
pyListPluginControlSubWedgeAssemble = []
# Prepare the action cluster
iIndex = 1
for xsDataCCP4iDataSet in _pyListXSDataCCP4iDataSet:
edPluginControlSubWedgeAssemble = self.loadPlugin(
self.__strPluginControlSubWedgeAssembleName,
"SubWedgeAssemble-%02d" % iIndex)
edPluginControlSubWedgeAssemble.connectSUCCESS(
self.doSuccessActionSubWedgeAssemble)
edPluginControlSubWedgeAssemble.connectFAILURE(
self.doFailureActionSubWedgeAssemble)
# Prepare the input for the sub wedge assemble plugin
xsDataInputSubWedgeAssemble = XSDataInputSubWedgeAssemble()
for xsDataImageFile in xsDataCCP4iDataSet.getImageFile():
xsDataInputSubWedgeAssemble.addFile(xsDataImageFile)
edPluginControlSubWedgeAssemble.setDataInput(
xsDataInputSubWedgeAssemble)
pyListPluginControlSubWedgeAssemble.append(
edPluginControlSubWedgeAssemble)
self.addPluginToActionCluster(edPluginControlSubWedgeAssemble)
iIndex += 1
# Run the action cluster synchronously
self.executeActionCluster()
self.synchronizeActionCluster()
# Recuperate the output
for edPluginControlSubWedgeAssemble in pyListPluginControlSubWedgeAssemble:
if (edPluginControlSubWedgeAssemble.isFailure()):
self.setFailure()
else:
xsDataResultSubWedgeAssemble = edPluginControlSubWedgeAssemble.getDataOutput(
)
for xsDataSubWedge in xsDataResultSubWedgeAssemble.getSubWedge(
):
# Instantiate the xsDataInputCharacterisation object if it's not already done.
xsDataCollection = None
if (xsDataInputCharacterisation is None):
xsDataInputCharacterisation = XSDataInputCharacterisation(
)
else:
xsDataCollection = xsDataInputCharacterisation.getDataCollection(
)
if (xsDataCollection is None):
xsDataCollection = XSDataCollection()
xsDataCollection.addSubWedge(xsDataSubWedge)
xsDataInputCharacterisation.setDataCollection(
xsDataCollection)
return xsDataInputCharacterisation
def addPluginToActionCluster(self, _edPlugin):
"""
This method adds a plugin instance to an action cluster.
"""
if self.__edActionCluster == None:
self.__edActionCluster = EDActionCluster()
self.__edActionCluster.addAction(_edPlugin)
self.__listOfLoadedPlugins.append(_edPlugin)
def testExecuteActionClusterWithSuccess(self):
"""
Test the EDActionCluster with actions ending in success
"""
edActionCluster = EDActionCluster()
for i in range(10):
edAction = EDActionSuccess()
edActionCluster.addAction(edAction)
edActionCluster.executeSynchronous()
EDAssert.equal(False, edActionCluster.isFailure(),
"EDActionCluster ended in success")
def process(self, _edObject=None):
EDPluginControl.process(self)
self.DEBUG("EDPluginControlIndexingIndicatorsv10.process")
edActionCluster = EDActionCluster()
edActionCluster.addAction(self.__edPluginMOSFLMIndexing)
edActionCluster.addAction(self.__edPluginControlIndicators)
self.__edPluginMOSFLMIndexing.connectSUCCESS(
self.doSuccessMOSFLMIndexing)
self.__edPluginMOSFLMIndexing.connectFAILURE(
self.doFailureMOSFLMIndexing)
self.__edPluginControlIndicators.connectSUCCESS(
self.doSuccessControlIndicators)
self.__edPluginControlIndicators.connectFAILURE(
self.doFailureControlIndicators)
edActionCluster.execute()
edActionCluster.synchronize()
def __init__(self, _edControlPlugin, _strPluginName, _dictXSDataInput,
_iNbThreads):
"""
Initialaze data structures
@param _edControlPlugin: Parent control plugin
@param _strPluginName: Name of the execution plugin to run
@param _dictXSDataInput: Dictionary of the input objects for execution plugin
"""
self.__strPluginName = _strPluginName
self.__dictXSDataInput = _dictXSDataInput
self.__edControlPlugin = _edControlPlugin
self.__xsEDPluginExecJobs = {}
self.__xsEDActionCluster = EDActionCluster(_iNbThreads)
self.__bIsFirstExecute = True
def process(self, _edObject=None):
EDPluginControl.process(self)
self.DEBUG("EDPluginControlIndexingIndicatorsv1_1.process")
edActionCluster = EDActionCluster()
if self.bDoLabelitIndexing:
edActionCluster.addAction(self.edPluginIndexingLabelit)
self.edPluginIndexingLabelit.connectSUCCESS(
self.doSuccessLabelitIndexing)
self.edPluginIndexingLabelit.connectFAILURE(
self.doFailureLabelitIndexing)
edActionCluster.addAction(self.edPluginControlIndicators)
self.edPluginControlIndicators.connectSUCCESS(
self.doSuccessControlIndicators)
self.edPluginControlIndicators.connectFAILURE(
self.doFailureControlIndicators)
edActionCluster.execute()
edActionCluster.synchronize()
def process(self, _edObject=None):
EDPluginControl.process(self)
self.DEBUG("EDPluginControlSaxsModelingv1_0.process")
xsDataInputDammif = XSDataInputDammif(gnomOutputFile=self.xsGnomFile,
unit=XSDataString(self.unit),
symmetry=XSDataString(
self.symmetry),
mode=XSDataString(self.mode))
for i in range(self.dammif_jobs):
dammif = self.loadPlugin(self.strPluginExecDammif)
dammif.connectSUCCESS(self.doSuccessExecDammif)
dammif.connectFAILURE(self.doFailureExecDammif)
xsd = xsDataInputDammif.copyViaDict()
xsd.order = XSDataInteger(i + 1)
dammif.dataInput = xsd
self.addPluginToActionCluster(dammif)
self.dammif_plugins.append(dammif)
self.executeActionCluster()
self.synchronizeActionCluster()
for plugin in self.dammif_plugins:
if plugin.isFailure():
self.ERROR("dammif plugin %s-%08i failed" %
(plugin.getName(), plugin.getId()))
self.setFailure()
self.retrieveMessages(plugin)
if self.isFailure():
return
# retrieve results from best dammif
self.dammif = self.bestDammif()
self.chi2plot("chi2_R.png")
self.result.chiRfactorPlot = XSDataFile(
XSDataString(os.path.join(self.getWorkingDirectory(),
"chi2_R.png")))
# temporary results: use best dammif
self.result.fitFile = self.dammif.dataOutput.fitFile
self.result.logFile = self.dammif.dataOutput.logFile
self.result.pdbMoleculeFile = self.dammif.dataOutput.pdbMoleculeFile
self.result.pdbSolventFile = self.dammif.dataOutput.pdbSolventFile
# prepare an action cluster with all supcomb plugins
self.actclust_supcomb = EDActionCluster(self.cluster_size)
for idx in range(self.dammif_jobs):
if self.valid[idx]:
for ser in range(idx):
if self.valid[ser]:
supcomb = self.loadPlugin(self.strPluginExecSupcomb)
supcomb.dataInput = XSDataInputSupcomb(
templateFile=self.dammif_plugins[idx].dataOutput.
pdbMoleculeFile,
superimposeFile=self.dammif_plugins[ser].
dataOutput.pdbMoleculeFile,
name=self.dammif_plugins[ser].dataOutput.model.name
)
self.supcomb_plugins[(idx, ser)] = supcomb
self.actclust_supcomb.addAction(supcomb)
self.actclust_supcomb.executeSynchronous()
for key, plugin in self.supcomb_plugins.items():
if plugin.isFailure():
self.ERROR(
"supcomb plugin for model pair (%i,%i) %s-%08i failed" %
(key[0] + 1, key[1] + 1, plugin.getName(), plugin.getId()))
self.setFailure()
self.retrieveMessages(plugin)
if self.isFailure():
return
self.makeNSDarray("nsd.png")
self.result.nsdPlot = XSDataFile(
XSDataString(os.path.join(self.getWorkingDirectory(), "nsd.png")))
idx = self.ref
self.actclust_supcomb = EDActionCluster(self.cluster_size)
for ser in range(self.ref + 1, self.dammif_jobs):
if self.valid[ser]:
supcomb = self.loadPlugin(self.strPluginExecSupcomb)
supcomb.dataInput = XSDataInputSupcomb(
templateFile=self.dammif_plugins[
self.ref].dataOutput.pdbMoleculeFile,
superimposeFile=self.dammif_plugins[ser].dataOutput.
pdbMoleculeFile,
name=self.dammif_plugins[ser].dataOutput.model.name)
self.supcomb_plugins[(self.ref, ser)] = supcomb
self.actclust_supcomb.addAction(supcomb)
self.actclust_supcomb.executeSynchronous()
for ser in range(self.ref + 1, self.dammif_jobs):
if self.valid[ser]:
plugin = self.supcomb_plugins[(self.ref, ser)]
if plugin.isFailure():
self.ERROR(
"supcomb plugin for model pair (%i,%i) %s-%08i failed"
% (self.ref + 1, ser + 1, plugin.getName(),
plugin.getId()))
self.setFailure()
self.retrieveMessages(plugin)
if self.isFailure():
return
for i in range(self.dammif_jobs):
if i == self.ref or not self.valid[i]:
model = self.dammif_plugins[i].dataOutput.model
else:
model = self.supcomb_plugins[(self.ref, i)].dataOutput.model
model.chiSqrt = self.dammif_plugins[i].dataOutput.model.chiSqrt
# model.chiSqrt = self.dammif_plugins[i].dataOutput.model.chiSqrt
self.symlink(model.pdbFile.path.value, "model-%02i.pdb" % (i + 1))
self.result.dammifModels[i] = model
# Now that all (valid) models are aligned we can combine them using damaver
pdbFiles = [self.dammif_plugins[self.ref].dataOutput.pdbMoleculeFile]
for idx in range(self.dammif_jobs):
if self.valid[idx] and idx != self.ref:
pdbFiles.append(
self.supcomb_plugins[(self.ref,
idx)].dataOutput.outputFilename)
damaver = self.loadPlugin(self.strPluginExecDamaver)
damaver.dataInput = XSDataInputDamaver(pdbInputFiles=pdbFiles,
automatic=XSDataBoolean(False))
damaver.connectSUCCESS(self.doSuccessExecDamaver)
damaver.connectFAILURE(self.doFailureExecDamaver)
damaver.executeSynchronous()
if self.isFailure():
return
damfilt = self.loadPlugin(self.strPluginExecDamfilt)
damfilt.dataInput = XSDataInputDamfilt(
inputPdbFile=damaver.dataOutput.damaverPdbFile)
damfilt.connectSUCCESS(self.doSuccessExecDamfilt)
damfilt.connectFAILURE(self.doFailureExecDamfilt)
damfilt.execute()
########################################################################
# TODO: This is a dead end : do it in parallel
########################################################################
if self.isFailure():
return
damstart = self.loadPlugin(self.strPluginExecDamstart)
damstart.dataInput = XSDataInputDamstart(
inputPdbFile=damaver.dataOutput.damaverPdbFile)
damstart.connectSUCCESS(self.doSuccessExecDamstart)
damstart.connectFAILURE(self.doFailureExecDamstart)
damstart.executeSynchronous()
if self.isFailure():
return
########################################################################
# Finally call dammin
########################################################################
if self.config.get("do_dammin") in ["False", "0", False, 0]:
return
dammin = self.loadPlugin(self.strPluginExecDammin)
dammin.dataInput = XSDataInputDammin(
pdbInputFile=damstart.dataOutput.outputPdbFile,
gnomOutputFile=self.xsGnomFile,
symmetry=XSDataString(self.symmetry),
mode=XSDataString(self.mode))
dammin.connectSUCCESS(self.doSuccessExecDammin)
dammin.connectFAILURE(self.doFailureExecDammin)
dammin.executeSynchronous()
