def testCheckParameters(self):
xsDataInput = XSDataInputAutoRg()
xsDataInput.sample = XSDataSaxsSample()
xsDataInput.inputCurve = [XSDataFile()]
edPluginExecAutoRg = self.createPlugin()
edPluginExecAutoRg.setDataInput(xsDataInput)
edPluginExecAutoRg.checkParameters()
def testCheckParameters(self):
xsDataInput = XSDataInputAutoRg()
xsDataInput.sample = XSDataSaxsSample()
xsDataInput.inputCurve = [XSDataFile()]
edPluginExecAutoRg = self.createPlugin()
edPluginExecAutoRg.setDataInput(xsDataInput)
edPluginExecAutoRg.checkParameters()
def doSuccessReduce(self, _edPlugin=None):
self.DEBUG("EDPluginControlSaxsPipelinev1_0.doSuccessReduce")
self.retrieveSuccessMessages(
_edPlugin, "EDPluginControlSaxsPipelinev1_0.doSuccessReduce")
self.inputautorg = XSDataInputAutoRg(
inputCurve=[_edPlugin.dataOutput.mergedCurve])
self.inputautorg.sample = self.dataInput.sample
def process(self, _edObject=None):
EDPluginControl.process(self)
self.DEBUG("EDPluginControlSaxsAnalysisv1_0.process")
if self.autoRg is None:
self.edPluginAutoRg = self.loadPlugin(self.cpAutoRg)
self.edPluginAutoRg.dataInput = XSDataInputAutoRg(
inputCurve=[self.dataInput.scatterCurve])
self.edPluginAutoRg.connectSUCCESS(self.doSuccessRg)
self.edPluginAutoRg.connectFAILURE(self.doFailureRg)
self.edPluginAutoRg.executeSynchronous()
if self.isFailure():
return
self.edPluginDatGnom = self.loadPlugin(self.cpDatGnom)
self.edPluginDatGnom.dataInput = XSDataInputDatGnom(
inputCurve=self.dataInput.scatterCurve,
output=XSDataFile(XSDataString(self.gnomFile)),
rg=self.autoRg.rg,
skip=XSDataInteger(self.autoRg.firstPointUsed.value - 1))
self.edPluginDatGnom.connectSUCCESS(self.doSuccessGnom)
self.edPluginDatGnom.connectFAILURE(self.doFailureGnom)
self.edPluginDatGnom.executeSynchronous()
if self.gnom is None:
return
self.edPluginDatPorod = self.loadPlugin(self.cpDatPorod)
self.edPluginDatPorod.dataInput = XSDataInputDatPorod(
gnomFile=XSDataFile(XSDataString(self.gnomFile)))
self.edPluginDatPorod.connectSUCCESS(self.doSuccessPorod)
self.edPluginDatPorod.connectFAILURE(self.doFailurePorod)
self.edPluginDatPorod.executeSynchronous()
def process(self, _edObject=None):
EDPluginControl.process(self)
self.DEBUG("EDPluginBioSaxsHPLCv1_3.process")
xsdIn = XSDataInputBioSaxsProcessOneFilev1_0(rawImage=self.dataInput.rawImage,
sample=self.dataInput.sample,
experimentSetup=self.dataInput.experimentSetup,
rawImageSize=self.dataInput.rawImageSize,
normalizedImage=self.dataInput.normalizedImage,
integratedCurve=self.dataInput.integratedCurve,
runId=self.dataInput.runId,
frameId=self.dataInput.frameId)
self.edPluginProcessOneFile = self.loadPlugin(self.strControlledPluginProcessOneFile)
self.edPluginProcessOneFile.dataInput = xsdIn
self.edPluginProcessOneFile.connectSUCCESS(self.doSuccessProcessOneFile)
self.edPluginProcessOneFile.connectFAILURE(self.doFailureProcessOneFile)
self.edPluginProcessOneFile.executeSynchronous()
if self.isFailure():
return
xsdIn = XSDataInputDatcmp(inputCurve=[XSDataFile(XSDataString(self.hplc_run.first_curve)),
XSDataFile(XSDataString(self.curve))])
self.edPluginDatCmp = self.loadPlugin(self.strControlledPluginDatCmp)
self.edPluginDatCmp.dataInput = xsdIn
self.edPluginDatCmp.connectSUCCESS(self.doSuccessDatCmp)
self.edPluginDatCmp.connectFAILURE(self.doFailureDatCmp)
self.edPluginDatCmp.executeSynchronous()
if self.isFailure() or self.isBuffer:
return
if self.dataInput.subtractedCurve is not None:
subtracted = self.dataInput.subtractedCurve.path.value
else:
subtracted = os.path.splitext(self.curve)[0] + "_sub.dat"
if self.hplc_run.buffer is not None:
xsdIn = XSDataInputDatop(inputCurve=[XSDataFile(XSDataString(self.curve)),
XSDataFile(XSDataString(self.hplc_run.buffer))],
outputCurve=XSDataFile(XSDataString(subtracted)),
operation=XSDataString("sub"))
else:
xsdIn = XSDataInputDatop(inputCurve=[XSDataFile(XSDataString(self.curve)),
XSDataFile(XSDataString(self.hplc_run.first_curve))],
outputCurve=XSDataFile(XSDataString(subtracted)),
operation=XSDataString("sub"))
self.edPluginDatop = self.loadPlugin(self.strControlledPluginDatop)
self.edPluginDatop.dataInput = xsdIn
self.edPluginDatop.connectSUCCESS(self.doSuccessDatop)
self.edPluginDatop.connectFAILURE(self.doFailureDatop)
self.edPluginDatop.executeSynchronous()
if self.subtracted and os.path.exists(self.subtracted):
self.edPluginAutoRg = self.loadPlugin(self.strControlledPluginAutoRg)
self.edPluginAutoRg.dataInput = XSDataInputAutoRg(inputCurve=[XSDataFile(XSDataString(self.subtracted))])
self.edPluginAutoRg.connectSUCCESS(self.doSuccessAutoRg)
self.edPluginAutoRg.connectFAILURE(self.doFailureAutoRg)
self.edPluginAutoRg.executeSynchronous()
def process(self, _edObject=None):
EDPluginControl.process(self)
self.DEBUG("EDPluginBioSaxsHPLCv1_4.process")
xsdIn = XSDataInputBioSaxsProcessOneFilev1_0(rawImage=self.dataInput.rawImage,
sample=self.dataInput.sample,
experimentSetup=self.dataInput.experimentSetup,
rawImageSize=self.dataInput.rawImageSize,
normalizedImage=self.dataInput.normalizedImage,
integratedCurve=self.dataInput.integratedCurve,
runId=self.dataInput.runId,
frameId=self.dataInput.frameId)
self.edPluginProcessOneFile = self.loadPlugin(self.strControlledPluginProcessOneFile)
self.edPluginProcessOneFile.dataInput = xsdIn
self.edPluginProcessOneFile.connectSUCCESS(self.doSuccessProcessOneFile)
self.edPluginProcessOneFile.connectFAILURE(self.doFailureProcessOneFile)
self.edPluginProcessOneFile.executeSynchronous()
if self.isFailure():
return
xsdIn = XSDataInputDatcmp(inputCurve=[XSDataFile(XSDataString(self.hplc_run.first_curve)),
XSDataFile(XSDataString(self.curve))])
self.edPluginDatCmp = self.loadPlugin(self.strControlledPluginDatCmp)
self.edPluginDatCmp.dataInput = xsdIn
self.edPluginDatCmp.connectSUCCESS(self.doSuccessDatCmp)
self.edPluginDatCmp.connectFAILURE(self.doFailureDatCmp)
self.edPluginDatCmp.executeSynchronous()
if self.isFailure() or self.isBuffer:
return
#######################
# # DatOp subtraction ##
#######################
if self.dataInput.subtractedCurve is not None:
self.subtracted = self.dataInput.subtractedCurve.path.value
else:
self.subtracted = os.path.splitext(self.curve)[0] + "_sub.dat"
Isub = self.intensity - self.hplc_run.buffer_I
StdErr = numpy.sqrt(self.stdError * self.stdError + \
self.hplc_run.buffer_Stdev * self.hplc_run.buffer_Stdev)
with open(self.subtracted, "w") as outfile:
numpy.savetxt(outfile, numpy.vstack((self.hplc_run.q, Isub, StdErr)).T)
self.xsDataResult.subtractedCurve = XSDataFile(XSDataString(self.subtracted))
self.frame.subtracted = self.subtracted
if self.subtracted and os.path.exists(self.subtracted):
self.edPluginAutoRg = self.loadPlugin(self.strControlledPluginAutoRg)
self.edPluginAutoRg.dataInput = XSDataInputAutoRg(inputCurve=[XSDataFile(XSDataString(self.subtracted))])
self.edPluginAutoRg.connectSUCCESS(self.doSuccessAutoRg)
self.edPluginAutoRg.connectFAILURE(self.doFailureAutoRg)
self.edPluginAutoRg.executeSynchronous()
def process(self, _edObject=None):
EDPluginControl.process(self)
self.DEBUG("EDPluginBioSaxsSmartMergev1_1.process")
xsdwf = XSDataInputWaitMultiFile(timeOut=XSDataTime(30),
expectedSize=XSDataInteger(10000),
expectedFile=[XSDataFile(i.path) for i in self.lstInput])
self.__edPluginExecWaitFile.setDataInput(xsdwf)
self.__edPluginExecWaitFile.connectFAILURE(self.doFailureExecWait)
self.__edPluginExecWaitFile.connectSUCCESS(self.doSuccessExecWait)
self.__edPluginExecWaitFile.executeSynchronous()
if self.isFailure():
return
if len(self.lstInput) == 1:
shutil.copyfile(self.lstInput[0].path.value, self.dataInput.mergedCurve.path.value)
else:
self.lstMerged = []
if (self.absoluteFidelity is not None) or (self.relativeFidelity is not None):
if self.absoluteFidelity is not None :
for idx, oneFile in enumerate(self.lstInput[1:]):
self.DEBUG("Calculating similarity of 0 and %s" % idx)
edPluginExecAbsoluteFidelity = self.loadPlugin(self.__strControlledPluginDatcmp)
xsd = XSDataInputDatcmp(inputCurve=[self.lstInput[0], oneFile])
edPluginExecAbsoluteFidelity.setDataInput(xsd)
edPluginExecAbsoluteFidelity.connectFAILURE(self.doFailureExecDatcmp)
edPluginExecAbsoluteFidelity.connectSUCCESS(self.doSuccessExecDatcmp)
edPluginExecAbsoluteFidelity.execute()
if (self.relativeFidelity is not None):
if (self.absoluteFidelity is None):
self.DEBUG("Calculating similarity of 0 and 1")
edPluginExecAbsoluteFidelity = self.loadPlugin(self.__strControlledPluginDatcmp)
xsd = XSDataInputDatcmp(inputCurve=[self.lstInput[0], self.lstInput[1] ])
edPluginExecAbsoluteFidelity.setDataInput(xsd)
edPluginExecAbsoluteFidelity.connectFAILURE(self.doFailureExecDatcmp)
edPluginExecAbsoluteFidelity.connectSUCCESS(self.doSuccessExecDatcmp)
edPluginExecAbsoluteFidelity.execute()
if (len(self.lstInput) > 2):
for idx, oneFile in enumerate(self.lstInput[2:]):
self.DEBUG("Calculating similarity of %s and %s" % (idx, idx + 1))
edPluginExecRelativeFidelity = self.loadPlugin(self.__strControlledPluginDatcmp)
xsd = XSDataInputDatcmp(inputCurve=[self.lstInput[idx + 1], oneFile])
edPluginExecRelativeFidelity.setDataInput(xsd)
edPluginExecRelativeFidelity.connectFAILURE(self.doFailureExecDatcmp)
edPluginExecRelativeFidelity.connectSUCCESS(self.doSuccessExecDatcmp)
edPluginExecRelativeFidelity.execute()
self.synchronizePlugins()
for idx, oneFile in enumerate(self.lstInput):
if idx == 0:
self.lstMerged.append(oneFile)
elif (self.absoluteFidelity is not None) and (self.relativeFidelity is not None):
if (idx - 1, idx) not in self.dictSimilarities:
self.ERROR("dict missing %i,%i: \n" % (idx - 1, idx) + "\n".join([ "%s: %s" % (key, self.dictSimilarities[key]) for key in self.dictSimilarities]))
if (0, idx) not in self.dictSimilarities:
self.ERROR("dict missing %i,%i: \n" % (0, idx) + "\n".join([ "%s: %s" % (key, self.dictSimilarities[key]) for key in self.dictSimilarities]))
if (self.dictSimilarities[(0, idx)] >= self.absoluteFidelity) and (self.dictSimilarities[(idx - 1, idx)] >= self.relativeFidelity):
self.lstMerged.append(oneFile)
else:
break
elif (self.absoluteFidelity is not None) :
if (0, idx) not in self.dictSimilarities:
self.ERROR("dict missing %i,%i: \n" % (0, idx) + "\n".join([ "%s: %s" % (key, self.dictSimilarities[key]) for key in self.dictSimilarities]))
if (self.dictSimilarities[(0, idx)] >= self.absoluteFidelity):
self.lstMerged.append(oneFile)
else:
break
elif (self.relativeFidelity is not None) :
if (idx - 1, idx) not in self.dictSimilarities:
self.ERROR("dict missing %i,%i: \n" % (idx - 1, idx) + "\n".join([ "%s: %s" % (key, self.dictSimilarities[key]) for key in self.dictSimilarities]))
if (self.dictSimilarities[(idx - 1, idx)] >= self.relativeFidelity):
self.lstMerged.append(oneFile)
else:
break
else:
self.lstMerged.append(oneFile)
self.lstMerged.sort(cmp)
if len(self.lstMerged) != len(self.lstInput):
self.strRadiationDamage = "Radiation damage detected, merged %i curves" % len(self.lstMerged)
self.WARNING(self.strRadiationDamage)
self.lstSummary.append("WARNING: " + self.strRadiationDamage)
self.lstSummary.append("Merging files: " + " ".join([os.path.basename(i.path.value) for i in self.lstMerged]))
if len(self.lstMerged) == 1:
shutil.copyfile(self.lstMerged[0].path.value, self.dataInput.mergedCurve.path.value)
else:
self.__edPluginExecDataver = self.loadPlugin(self.__strControlledPluginDataver)
xsd = XSDataInputDataver(inputCurve=self.lstMerged)
#outputCurve=self.dataInput.mergedCurve,
self.__edPluginExecDataver.setDataInput(xsd)
self.__edPluginExecDataver.connectSUCCESS(self.doSuccessExecDataver)
self.__edPluginExecDataver.connectFAILURE(self.doFailureExecDataver)
self.__edPluginExecDataver.executeSynchronous()
if self.isFailure():
return
self.__edPluginExecAutoRg = self.loadPlugin(self.__strControlledPluginAutoRG)
xsd = XSDataInputAutoRg(inputCurve=[self.dataInput.mergedCurve])
self.__edPluginExecAutoRg.setDataInput(xsd)
self.__edPluginExecAutoRg.connectSUCCESS(self.doSuccessExecAutoRg)
self.__edPluginExecAutoRg.connectFAILURE(self.doFailureExecAutoRg)
self.__edPluginExecAutoRg.executeSynchronous()
def process(self, _edObject=None):
EDPluginControl.process(self)
self.DEBUG("EDPluginAutoSubv1_0.process")
basename = os.path.splitext(os.path.basename(self.sampleCurve))[0]
self.bestBuffer = os.path.join(self.outdir,
"%s_bestbuffer.dat" % basename)
self.averBuffer = os.path.join(self.outdir,
"%s_averbuffer.dat" % basename)
for idx, name in enumerate(self.buffers):
copy(name,
os.path.join(self.outdir, "%s_buf%i.dat" % (basename, idx)))
if len(self.buffers) == 1:
self.actualBestBuffer = self.buffers[0]
else:
self.__edPluginDataver.dataInput = XSDataInputDataver(
inputCurve=self.dataInput.buffers,
outputCurve=XSDataFile(XSDataString(self.averBuffer)))
self.__edPluginDataver.connectSUCCESS(self.doSuccessExecDataver)
self.__edPluginDataver.connectFAILURE(self.doFailureExecDataver)
self.__edPluginDataver.execute()
if len(self.buffers) == 2:
edPluginDatcmp = self.loadPlugin(self.__strPluginDatcmp)
edPluginDatcmp.dataInput = XSDataInputDatcmp(
inputCurve=self.dataInput.buffers)
edPluginDatcmp.connectSUCCESS(self.doSuccessExecDatcmp)
edPluginDatcmp.connectFAILURE(self.doFailureExecDatcmp)
edPluginDatcmp.executeSynchronous()
if self.isFailure() or (self.fidelity is None):
return
if self.fidelity < self.BUFFER_SIMILARITY: #buffer are not the same: keeping the one with lowest Rg/I0
edpluginRg = self.loadPlugin(self.__strPluginAutoRg)
edpluginRg.dataInput = XSDataInputAutoRg(
inputCurve=self.dataInput.buffers)
edpluginRg.connectSUCCESS(self.doSuccessExecAutoRg)
edpluginRg.connectFAILURE(self.doFailureExecAutoRg)
edpluginRg.executeSynchronous()
self.actualBestBuffer = self.dictRg.keys()[
self.dictRg.values().index(min(self.dictRg.values()))]
else:
self.actualBestBuffer = self.averBuffer
else:
self.synchronizePlugins()
strError = "You should specify exactly 2 buffers for guessing best buffer, I got: " + ", ".join(
self.buffers)
self.WARNING(strError)
self.lstProcessLog.append(strError)
self.actualBestBuffer = self.averBuffer
copy(self.actualBestBuffer, self.bestBuffer)
self.lstProcessLog.append("Best buffer is %s" % self.actualBestBuffer)
if self.isFailure() or not os.path.exists(
self.bestBuffer) or not os.path.exists(self.sampleCurve):
return
edPluginDatop = self.loadPlugin(self.__strPluginDatop)
edPluginDatop.dataInput = XSDataInputDatop(
operation=XSDataString("SUB"),
outputCurve=XSDataFile(XSDataString(self.subtractedCurve)),
inputCurve=[
XSDataFile(XSDataString(self.sampleCurve)),
XSDataFile(XSDataString(self.bestBuffer))
])
edPluginDatop.connectSUCCESS(self.doSuccessExecDatop)
edPluginDatop.connectFAILURE(self.doFailureExecDatop)
edPluginDatop.executeSynchronous()
if self.isFailure() or not os.path.exists(self.subtractedCurve):
return
self.headers = self.parseHeaders(self.sampleCurve)
edpluginRg = self.loadPlugin(self.__strPluginAutoRg)
edpluginRg.dataInput = XSDataInputAutoRg(
inputCurve=[XSDataFile(XSDataString(self.subtractedCurve))])
edpluginRg.connectSUCCESS(self.doSuccessExecAutoRg)
edpluginRg.connectFAILURE(self.doFailureExecAutoRg)
edpluginRg.executeSynchronous()
def process(self, _edObject=None):
EDPluginControl.process(self)
self.DEBUG("EDPluginAutoSubv1_1.process")
basename = os.path.splitext(os.path.basename(self.sampleCurve))[0]
self.bestBuffer = os.path.join(self.outdir,
"%s_bestbuffer.dat" % basename)
self.averBuffer = os.path.join(self.outdir,
"%s_averbuffer.dat" % basename)
self.data = numpy.loadtxt(self.sampleCurve)
for idx, name in enumerate(self.buffers):
copy(name,
os.path.join(self.outdir, "%s_buf%i.dat" % (basename, idx)))
if len(self.buffers) == 1:
self.actualBestBuffer = self.buffers[0]
self.bestBufferType = str(self.actualBestBuffer)
self.bufferIntensity = numpy.loadtxt(self.buffers[0])
else:
# self.__edPluginDataver.dataInput = XSDataInputDataver(inputCurve=self.dataInput.buffers,
# outputCurve=XSDataFile(XSDataString(self.averBuffer)))
# self.__edPluginDataver.connectSUCCESS(self.doSuccessExecDataver)
# self.__edPluginDataver.connectFAILURE(self.doFailureExecDataver)
# self.__edPluginDataver.execute()
if len(self.buffers) == 2:
self.bufferData[self.buffers[0]] = numpy.loadtxt(
self.buffers[0])
self.bufferData[self.buffers[1]] = numpy.loadtxt(
self.buffers[1])
#Average
AverageIntensity = (self.bufferData[self.buffers[0]][:, 1] +
self.bufferData[self.buffers[1]][:, 1]) / 2
StdErr = numpy.sqrt((self.bufferData[self.buffers[0]][:,2] * self.bufferData[self.buffers[0]][:,2]+ \
self.bufferData[self.buffers[1]][:,2] * self.bufferData[self.buffers[1]][:,2])/2)
self.averageBuffer = numpy.vstack(
(self.bufferData[self.buffers[0]][:, 0], AverageIntensity,
StdErr)).T
with open(self.averBuffer, "w") as outfile:
numpy.savetxt(outfile, self.averageBuffer)
self.datcmp(self.bufferData[self.buffers[0]],
self.bufferData[self.buffers[1]])
# edPluginDatcmp = self.loadPlugin(self.__strPluginDatcmp)
# edPluginDatcmp.dataInput = XSDataInputDatcmp(inputCurve=self.dataInput.buffers)
# edPluginDatcmp.connectSUCCESS(self.doSuccessExecDatcmp)
# edPluginDatcmp.connectFAILURE(self.doFailureExecDatcmp)
# edPluginDatcmp.executeSynchronous()
if self.isFailure() or (self.fidelity is None):
return
if self.fidelity < self.BUFFER_SIMILARITY:
print "Different buffers"
# buffer are not the same: keeping the one with lowest Rg/I0 for the subtraction
#data = numpy.loadtxt(self.sampleCurve.path.value)
for buff in self.buffers:
tempName = os.path.splitext(buff)[0] + '.sub'
self.doSubtract(self.data, self.bufferData[buff],
tempName)
# Isub = data [:,1] - self.bufferData[buff][:,1]
# StdErr = numpy.sqrt(data[:,2] * data[:,2] + \
# self.bufferData[buff][:,2] * self.bufferData[buff][:,2])
#
# with open(tempName, "w") as outfile:
# numpy.savetxt(outfile, numpy.vstack((data[:,0], Isub, StdErr)).T)
# edPluginDatop = self.loadPlugin(self.__strPluginDatop)
# edPluginDatop.dataInput = XSDataInputDatop(operation=XSDataString("SUB"),
# outputCurve=XSDataFile(XSDataString(os.path.splitext(buff)[0] + '.sub')),
# inputCurve=[XSDataFile(XSDataString(self.sampleCurve)), XSDataFile(XSDataString(buff))])
# edPluginDatop.connectSUCCESS(self.doSuccessExecDatop)
# edPluginDatop.connectFAILURE(self.doFailureExecDatop)
# edPluginDatop.executeSynchronous()
self.tempSub += [XSDataFile(XSDataString(tempName))]
edpluginRg = self.loadPlugin(self.__strPluginAutoRg)
edpluginRg.dataInput = XSDataInputAutoRg(
inputCurve=self.tempSub)
edpluginRg.connectSUCCESS(self.doSuccessExecAutoRg)
edpluginRg.connectFAILURE(self.doFailureExecAutoRg)
edpluginRg.executeSynchronous()
actualBestTmp = self.dictRg.keys()[
self.dictRg.values().index(min(self.dictRg.values()))]
self.actualBestBuffer = os.path.splitext(
actualBestTmp)[0] + '.dat'
self.bestBufferType = str(self.actualBestBuffer)
self.bufferIntensity = self.bufferData[
self.actualBestBuffer]
else:
print "similar buffers"
self.actualBestBuffer = self.averBuffer
self.bestBufferType = "average"
self.bufferIntensity = self.averageBuffer
print self.actualBestBuffer
else:
self.synchronizePlugins()
strError = "You should specify exactly 2 buffers for guessing best buffer, I got: " + ", ".join(
self.buffers)
self.WARNING(strError)
self.lstProcessLog.append(strError)
self.actualBestBuffer = self.averBuffer
self.bufferIntensity = self.averageBuffer
copy(self.actualBestBuffer, self.bestBuffer)
print "copied to ", self.bestBuffer
self.lstProcessLog.append("Best buffer is %s" % self.actualBestBuffer)
if self.isFailure() or not os.path.exists(
self.bestBuffer) or not os.path.exists(self.sampleCurve):
return
# edPluginDatop = self.loadPlugin(self.__strPluginDatop)
# edPluginDatop.dataInput = XSDataInputDatop(operation=XSDataString("SUB"),
# outputCurve=XSDataFile(XSDataString(self.subtractedCurve)),
# inputCurve=[XSDataFile(XSDataString(self.sampleCurve)), XSDataFile(XSDataString(self.bestBuffer))])
# edPluginDatop.connectSUCCESS(self.doSuccessExecDatop)
# edPluginDatop.connectFAILURE(self.doFailureExecDatop)
# edPluginDatop.executeSynchronous()
self.doSubtract(self.data, self.bufferIntensity, self.subtractedCurve)
if self.isFailure() or not os.path.exists(self.subtractedCurve):
return
self.headers = self.parseHeaders(self.sampleCurve)
edpluginRg = self.loadPlugin(self.__strPluginAutoRg)
edpluginRg.dataInput = XSDataInputAutoRg(
inputCurve=[XSDataFile(XSDataString(self.subtractedCurve))])
edpluginRg.connectSUCCESS(self.doSuccessExecAutoRg)
edpluginRg.connectFAILURE(self.doFailureExecAutoRg)
edpluginRg.executeSynchronous()
def process(self, _edObject=None):
EDPluginControl.process(self)
self.DEBUG("EDPluginControlSaxsAnalysisv1_1.process")
if self.autoRg is None:
self.edPluginAutoRg = self.loadPlugin(self.cpAutoRg)
self.edPluginAutoRg.dataInput = XSDataInputAutoRg(inputCurve=[self.dataInput.scatterCurve])
self.edPluginAutoRg.connectSUCCESS(self.doSuccessRg)
self.edPluginAutoRg.connectFAILURE(self.doFailureRg)
self.edPluginAutoRg.executeSynchronous()
if self.autoRg is None:
self.setFailure()
if self.isFailure():
return
self.edPluginDatGnom = self.loadPlugin(self.cpDatGnom)
self.edPluginDatGnom.dataInput = XSDataInputDatGnom(inputCurve=self.dataInput.scatterCurve,
output=XSDataFile(XSDataString(self.gnomFile)),
rg=self.autoRg.rg,
skip=XSDataInteger(self.autoRg.firstPointUsed.value - 1))
self.edPluginDatGnom.connectSUCCESS(self.doSuccessGnom)
self.edPluginDatGnom.connectFAILURE(self.doFailureGnom)
self.edPluginDatGnom.executeSynchronous()
if self.gnom is None:
return
self.edPluginDatPorod = self.loadPlugin(self.cpDatPorod)
self.edPluginDatPorod.dataInput = XSDataInputDatPorod(gnomFile=XSDataFile(XSDataString(self.gnomFile)))
self.edPluginDatPorod.connectSUCCESS(self.doSuccessPorod)
self.edPluginDatPorod.connectFAILURE(self.doFailurePorod)
self.edPluginDatPorod.execute()
if self.dataInput.graphFormat:
ext = self.dataInput.graphFormat.value
if not ext.startswith("."):
ext = "." + ext
plt = sys.modules.get("matplotlib.pyplot")
try:
guinierfile = os.path.join(self.getWorkingDirectory(), os.path.basename(self.scatterFile).split(".")[0] + "-Guinier" + ext)
# guinierplot = guinierPlot(self.scatterFile, unit="nm",
# filename=guinierfile, format=ext[1:])
guinierplot = guinierPlot(self.scatterFile, unit="nm",
filename=guinierfile, format=ext[1:], first_point=self.autoRg.firstPointUsed.value,
last_point=self.autoRg.lastPointUsed.value)
guinierplot.clf()
if plt:
plt.close(guinierplot)
except Exception as error:
self.ERROR("EDPluginControlSaxsAnalysisv1_1 in guinierplot: %s" % error)
else:
self.xsDataResult.guinierPlot = XSDataFile(XSDataString(guinierfile))
try:
kratkyfile = os.path.join(self.getWorkingDirectory(), os.path.basename(self.scatterFile).split(".")[0] + "-Kratky" + ext)
kratkyplot = kartkyPlot(self.scatterFile, unit="nm",
filename=kratkyfile, format=ext[1:])
kratkyplot.clf()
if plt:
plt.close(kratkyplot)
except Exception as error:
self.ERROR("EDPluginControlSaxsAnalysisv1_1 in kratkyplot: %s" % error)
else:
self.xsDataResult.kratkyPlot = XSDataFile(XSDataString(kratkyfile))
if self.autoRg is not None:
if self.autoRg.i0.value > 0 and self.autoRg.rg.value > 0:
try:
kratkyRgfile = os.path.join(self.getWorkingDirectory(), os.path.basename(self.scatterFile).split(".")[0] + "-KratkyRg" + ext)
kratkyRgplot = kratkyRgPlot(self.scatterFile, self.autoRg.i0.value, self.autoRg.rg.value,
filename=kratkyRgfile, format=ext[1:])
kratkyRgplot.clf()
if plt:
plt.close(kratkyRgplot)
except Exception as error:
self.ERROR("EDPluginControlSaxsAnalysisv1_1 in kratkyRgplot: %s" % error)
else:
self.xsDataResult.kratkyRgPlot = XSDataFile(XSDataString(kratkyRgfile))
if self.autoRg is not None and self.rti is not None:
if self.autoRg.i0.value > 0 and self.rti.vc.value > 0:
try:
kratkyVcfile = os.path.join(self.getWorkingDirectory(), os.path.basename(self.scatterFile).split(".")[0] + "-KratkyVc" + ext)
kratkyVcplot = kratkyVcPlot(self.scatterFile, self.autoRg.i0.value, self.rti.vc.value,
filename=kratkyVcfile, format=ext[1:])
kratkyVcplot.clf()
if plt:
plt.close(kratkyVcplot)
except Exception as error:
self.ERROR("EDPluginControlSaxsAnalysisv1_1 in kratkyVcplot: %s" % error)
else:
self.xsDataResult.kratkyVcPlot = XSDataFile(XSDataString(kratkyVcfile))
try:
scatterplotfile = os.path.join(self.getWorkingDirectory(), os.path.basename(self.scatterFile).split(".")[0] + "-scattering" + ext)
scatterplot = scatterPlot(self.scatterFile, unit="nm", gnomfile=self.gnomFile,
filename=scatterplotfile, format=ext[1:])
scatterplot.clf()
if plt:
plt.close(scatterplot)
except Exception as error:
self.ERROR("EDPluginControlSaxsAnalysisv1_1 in scatterplot: %s" % error)
else:
self.xsDataResult.scatterPlot = XSDataFile(XSDataString(scatterplotfile))
try:
densityplotfile = os.path.join(self.getWorkingDirectory(), os.path.basename(self.scatterFile).split(".")[0] + "-density" + ext)
densityplot = densityPlot(gnomfile=self.gnomFile, unit="nm",
filename=densityplotfile, format=ext[1:])
densityplot.clf()
if plt:
plt.close(densityplot)
except Exception as error:
self.ERROR("EDPluginControlSaxsAnalysisv1_1 in scatterplot: %s" % error)
else:
self.xsDataResult.densityPlot = XSDataFile(XSDataString(densityplotfile))
gc.collect()
self.synchronizePlugins()
def process(self, _edObject=None):
EDPluginControl.process(self)
self.DEBUG("EDPluginBioSaxsHPLCv1_5.process")
xsdIn = XSDataInputBioSaxsProcessOneFilev1_0(rawImage=self.dataInput.rawImage,
sample=self.dataInput.sample,
experimentSetup=self.dataInput.experimentSetup,
rawImageSize=self.dataInput.rawImageSize,
normalizedImage=self.dataInput.normalizedImage,
integratedCurve=self.dataInput.integratedCurve,
runId=self.dataInput.runId,
frameId=self.dataInput.frameId)
self.edPluginProcessOneFile = self.loadPlugin(self.strControlledPluginProcessOneFile)
self.edPluginProcessOneFile.dataInput = xsdIn
self.edPluginProcessOneFile.connectSUCCESS(self.doSuccessProcessOneFile)
self.edPluginProcessOneFile.connectFAILURE(self.doFailureProcessOneFile)
self.edPluginProcessOneFile.executeSynchronous()
if self.isFailure():
return
if self.hplc_run.first_curve == self.curve:
return
# xsdIn = XSDataInputDatcmp(inputCurve=[XSDataFile(XSDataString(self.hplc_run.first_curve)),
# XSDataFile(XSDataString(self.curve))])
# self.edPluginDatCmp = self.loadPlugin(self.strControlledPluginDatCmp)
# self.edPluginDatCmp.dataInput = xsdIn
# self.edPluginDatCmp.connectSUCCESS(self.doSuccessDatCmp)
# self.edPluginDatCmp.connectFAILURE(self.doFailureDatCmp)
# self.edPluginDatCmp.executeSynchronous()
self.datcmp(self.hplc_run.firstCurveIntensity, self.intensity)
if self.isFailure() or self.isBuffer:
return
#######################
# # DatOp subtraction ##
#######################
if self.dataInput.subtractedCurve is not None:
self.subtracted = self.dataInput.subtractedCurve.path.value
else:
self.subtracted = os.path.splitext(self.curve)[0] + "_sub.dat"
Isub = self.intensity - self.hplc_run.buffer_I
StdErr = numpy.sqrt(self.stdError * self.stdError + \
self.hplc_run.buffer_Stdev * self.hplc_run.buffer_Stdev)
self.SAXSdata= numpy.vstack((self.hplc_run.q, Isub, StdErr)).T
with open(self.subtracted, "w") as outfile:
#print "Writing file"
numpy.savetxt(outfile, self.SAXSdata)
self.xsDataResult.subtractedCurve = XSDataFile(XSDataString(self.subtracted))
self.frame.subtracted = self.subtracted
if self.subtracted and os.path.exists(self.subtracted) and self.ATSASRg:
self.edPluginAutoRg = self.loadPlugin(self.strControlledPluginAutoRg)
self.edPluginAutoRg.dataInput = XSDataInputAutoRg(inputCurve=[XSDataFile(XSDataString(self.subtracted))])
self.edPluginAutoRg.connectSUCCESS(self.doSuccessAutoRg)
self.edPluginAutoRg.connectFAILURE(self.doFailureAutoRg)
self.edPluginAutoRg.executeSynchronous()
try:
#print self.subtracted, autoRg(self.SAXSdata)
rg_result = autoRg(self.SAXSdata)
self.frame.RgF, self.frame.Rg_StdevF, self.frame.I0F, self.frame.I0_StdevF, self.frame.Rg_imin, self.frame.Rg_imax = rg_result[:6]
except InsufficientDataError:
print "Not enough usable data to run autorg"
except SystemError as SE:
print "System Error"
print SE
except Exception as Err:
print Err
raise
else:
if self.ATSASRg == False:
self.frame.Rg = max(0,self.frame.RgF)
self.frame.Rg_Stdev = max(0,self.frame.Rg_StdevF)
self.frame.I0 = max(0,self.frame.I0F)
self.frame.I0_Stdev = max(0,self.frame.I0_StdevF)
self.frame.quality = 0
"""
Calculate the invariants Vc and Qr from the Rambo&Tainer 2013 Paper,
also the the mass estimate based on Qr for proteins
"""
if self.subtracted and os.path.exists(self.subtracted):
self.subtracted_data = numpy.loadtxt(self.subtracted)
if self.subtracted_data is not None and\
self.frame.RgF and self.frame.Rg_StdevF and self.frame.I0F and self.frame.I0_StdevF:
dictRTI = RamboTainerInvariant(self.subtracted_data, self.frame.RgF,
self.frame.Rg_StdevF, self.frame.I0F,
self.frame.I0_StdevF, self.frame.Rg_imin)
# {'Vc': vc[0], 'dVc': vc[1], 'Qr': qr, 'dQr': dqr, 'mass': mass, 'dmass': dmass}
self.frame.Vc = dictRTI.get("Vc")
self.frame.Vc_Stdev = dictRTI.get("dVc")
self.frame.Qr = dictRTI.get("Qr")
self.frame.Qr_Stdev = dictRTI.get("dQ")
self.frame.mass = dictRTI.get("mass")
self.frame.mass_Stdev = dictRTI.get("dmass")
xsdRTI = XSDataRamboTainer(vc=XSDataDouble(self.frame.Vc),
qr=XSDataDouble(self.frame.Qr),
mass=XSDataDouble(self.frame.mass),
dvc=XSDataDouble(self.frame.Vc_Stdev),
dqr=XSDataDouble(self.frame.Qr_Stdev),
dmass=XSDataDouble(self.frame.mass_Stdev))
self.xsDataResult.rti = xsdRTI