Пример #1
0
 def createTestObjs(self):
     self.mockWorkflowA = mock.Mock()
     self.mockWorkflowA.preRunShellComms = self.preRunShellCommsA
     self.mockWorkflowA.output = self.output
     self.testLabelA = labelHelp.StandardLabel(eleKey=self.eleKey,
                                               structKey=self.structKey,
                                               methodKey=self.methodKey)
     self.testObjA = tCode.StandardInputObj(self.mockWorkflowA,
                                            self.testLabelA,
                                            mapFunction=self.mapFunction)
Пример #2
0
    def createTestObjs(self):
        self.labelA = labelHelp.StandardLabel(eleKey=self.eleKey,
                                              structKey=self.structKey,
                                              methodKey=self.methodKey)

        self.dataDictA = {"fake_key": "fake_val"}

        self.parsedFileA = types.SimpleNamespace(**self.dataDictA)
        dataObj = types.SimpleNamespace(parsedFile=self.parsedFileA)
        self.stdOutObjA = calcRunnersHelp.StandardOutputObj([dataObj],
                                                            self.labelA)
Пример #3
0
	def testCreateFromSelf(self, mockedWorkFlowGetter, mockedStdInp):
		expReactionFlow = mock.Mock()
		expOutObj = mock.Mock()
		expLabel = labelHelp.StandardLabel(eleKey=self.eleKey,structKey=self.structKey,methodKey=self.methodKey)

		mockedWorkFlowGetter.side_effect = [expReactionFlow]
		mockedStdInp.side_effect = [expOutObj]
		actOutObj = self.testObjA.create()

		mockedStdInp.assert_called_once_with(expReactionFlow, expLabel)
		self.assertEqual(expOutObj, actOutObj)
	def testExpectedArgsPassedToStandardInput(self, mockedWorkflowCreator, mockedStandardInput):
		expWorkflow = "fake_workflow"
		expFinalObject = "fake_standard_input"
		expLabel = labelHelp.StandardLabel(eleKey=self.eleKey, methodKey=self.methodKey, structKey=self.structKey)

		mockedWorkflowCreator.side_effect = lambda : expWorkflow
		mockedStandardInput.side_effect = lambda *args, **kwargs : expFinalObject

		actFinalObject = self.testObjA.create()
		mockedStandardInput.assert_called_once_with(expWorkflow, expLabel)
	
		self.assertEqual(expFinalObject, actFinalObject)
 def testSingleWorkflowCreation_CorrectArgsPassedToWorkflow(
         self, mockedEosFlow):
     testStructStr = self.structStrs[0]
     expLabel = labelHelp.StandardLabel(eleKey=self.eleKey,
                                        structKey=testStructStr,
                                        methodKey=self.methodKey)
     expArgs = [self.eosFitFunction, expLabel]
     self.testObjA._createSingleWorkflow(testStructStr)
     actArgs, unused_kwargs = mockedEosFlow.EosWorkflow.call_args
     self.assertEqual(
         expArgs, list(actArgs[1:])
     )  #Dont need or want to test what gets passed as calcObjs
Пример #6
0
 def createTestObjs(self):
     workflowOutputA = [
         types.SimpleNamespace(stackFaultEnergy=self.stackFaultA)
     ]
     labelObj = labelHelp.StandardLabel(eleKey=self.eleKey,
                                        structKey=self.structKey,
                                        methodKey=self.methodKey)
     workFlowA = types.SimpleNamespace(output=workflowOutputA,
                                       run=self.runFunction)
     self.testMapFunct = tCode.MapStackingFaultTwoStructsToUsefulFormatStandard(
         multStackFaultByFactor=self.multStackFaultByFactor)
     self.stdInpObj = calcRunners.StandardInputObj(workFlowA, labelObj)
Пример #7
0
	def createTestObjs(self):
		self.workflowA = mock.Mock()
		self.labelA = labelHelp.StandardLabel(eleKey=self.eleKey, structKey=self.structKey, methodKey=self.methodKey)
		self.stdInpObjA = calcRunnersHelp.StandardInputObj(self.workflowA, self.labelA)

		self.dataDictA = {"thermo_data":self.thermoObj, "trajectory":self.trajObj, "finalRunFolder":self.runFolder}
		self.dataA = [types.SimpleNamespace(parsedFile=types.SimpleNamespace(**self.dataDictA))]
		self.stdOutObjA = calcRunnersHelp.StandardOutputObj(self.dataA, self.labelA)

		currKwargs = {"copyWfnFile":self.copyWfnFiles, "copyRestartFile":self.copyRestartFiles, "maxNumbWfnBackups":self.maxNumbWfnBackups}
		self.testObjA = tCode.MDFilesFromOutObjsFileDumperStandard(**currKwargs)
		self.expPathExtA = os.path.join(self.eleKey, self.structKey, self.methodKey)
Пример #8
0
 def createTestObjects(self):
     labels = list()
     for eKey, mKey, sKey in it.zip_longest(self.eleKeys, self.methodKeys,
                                            self.structKeys):
         labels.append(
             baseLabels.StandardLabel(eleKey=eKey,
                                      methodKey=mKey,
                                      structKey=sKey))
     self.eleA = tCode._SearchableElement(labels[0])
     self.eleB = tCode._SearchableElement(labels[1])
     self.eleC = tCode._SearchableElement(labels[2])
     self.testObjA = tCode.SearchableCollection([self.eleA, self.eleB])
     self.testObjB = tCode.SearchableCollection([self.testObjA, self.eleC])
	def _createStandardInputForOneBasis(self, basisKeyDict, basisAlias):
		#Figure out the type of grid-convergence we're using
		gridVaryVals = self._getGridVaryVals()
		gridConvType = self._getGridConvType()

		#Create ALL the CP2K objects we need 
		calcFolder = os.path.join(self.baseWorkfolder, basisAlias, gridConvType)
		outLabel = labelHelp.StandardLabel(eleKey=self.eleKey, structKey=self.structKey, methodKey=basisAlias)
		allCP2KObjs = self._getAllRequiredCP2KObjs( basisKeyDict, calcFolder)

		#Create the input object
		outWorkflow = wflowConv.GridConvergenceEnergyWorkflow(allCP2KObjs, gridVaryVals)
		inputObj = calcRunners.StandardInputObj(outWorkflow, outLabel, mapFunction=self.workFlowToOutputObjMap)

		return inputObj
Пример #10
0
    def createTestObjs(self):

        labelA = labelHelp.StandardLabel(eleKey=self.eleKey,
                                         methodKey=self.methodKey,
                                         structKey=self.structKey)
        outputObj = types.SimpleNamespace(defectE=self.defectEnergyA,
                                          bulkEPerAtom=self.ePerAtomBulkA,
                                          defectEPerAtom=self.ePerAtomDefectA,
                                          run=mock.Mock())
        self.workflowA = types.SimpleNamespace(output=[outputObj],
                                               run=mock.Mock())
        self.testObjA = tCode.MapSelfDefectWorkflowOutputToUsefulFormatStandard(
            xVal=self.xVal)
        self.standardInpObjA = calcRunners.StandardInputObj(
            self.workflowA, labelA)
Пример #11
0
    def testExpectedCallToStandardInputCreator(self, mockedWorkflowGetter,
                                               mockedStandardInp):
        expLabel = labelHelp.StandardLabel(eleKey=self.eleKey,
                                           structKey=self.structKey,
                                           methodKey=self.methodKey)
        expStdInp, expWorkflow, expOutput = mock.Mock(), mock.Mock(
        ), mock.Mock()

        mockedWorkflowGetter.side_effect = lambda *args, **kwargs: expWorkflow
        mockedStandardInp.side_effect = lambda *args, **kwargs: expStdInp

        actOutput = self.testObjA.create()
        mockedWorkflowGetter.assert_called_with()
        mockedStandardInp.assert_called_with(expWorkflow, expLabel)
        self.assertEqual(expStdInp, actOutput)
Пример #12
0
    def testExpectedWorkflowForSingleStructStr(self, mockedWorkflow,
                                               mockedGetCalcObjs):
        expStructKey = "bcc"
        expFitFunct = self.eosFitFuncts[1]
        expLabel = labelHelp.StandardLabel(eleKey=self.eleKey,
                                           structKey=expStructKey,
                                           methodKey=self.methodKey)
        expCalcObjs, expWorkflow = mock.Mock(), mock.Mock()
        mockedGetCalcObjs.side_effect = lambda *args: expCalcObjs
        mockedWorkflow.side_effect = lambda *args, **kwargs: expWorkflow

        actOutput = self.testObjA._getWorkflowForStructStr(expStructKey)

        mockedGetCalcObjs.assert_called_with(expStructKey)
        mockedWorkflow.assert_called_with(expCalcObjs, expFitFunct, expLabel)
        self.assertEqual(expWorkflow, actOutput)
Пример #13
0
    def testCreateFromSelf(self, mockedBulkCreator, mockedDefectCreator,
                           mockedDefectFlow, mockedStandardInput):
        bulkCreator, defectCreator = mock.Mock(), mock.Mock()
        expBulkObj, expDefectObj = mock.Mock(), mock.Mock()
        expWorkflow = mock.Mock()
        mockedBulkCreator.side_effect = lambda *args, **kwargs: bulkCreator
        mockedDefectCreator.side_effect = lambda *args, **kwargs: defectCreator
        bulkCreator.create.side_effect = lambda *args, **kwargs: expBulkObj
        defectCreator.create.side_effect = lambda *args, **kwargs: expDefectObj
        mockedDefectFlow.side_effect = lambda *args, **kwargs: expWorkflow

        self.testObjA._createFromSelf()
        expLabel = labelHelp.StandardLabel(eleKey=self.eleKey,
                                           structKey=self.structKey,
                                           methodKey=self.methodKey)
        mockedDefectFlow.assert_called_once_with(expDefectObj, expBulkObj)
        mockedStandardInput.assert_called_once_with(expWorkflow, expLabel)
	def createTestObjs(self):
		labelA = labelHelp.StandardLabel(eleKey=self.eleKey,structKey=self.structKey,methodKey=self.methodKey)
		elasticStrs = ["c11","c12","c13","c33","c44"]
		elasticsInCorrectFormat = OrderedDict( [(strLabel,y) for strLabel,y in it.zip_longest(elasticStrs,self.elasticConstants)] )
		stressStrainData = [mock.Mock() for x in self.elasticConstants]
		self.testObjA = tCode.MapElasticflowOutputToUsefulFormatStandard(self.structStr, fitStrainVals=self.fitFunctXVals)
		self.testOutputA = types.SimpleNamespace(**{"elasticConsts":elasticsInCorrectFormat,"stressStrainData":stressStrainData,
		                                            "strains":self.strainObjs})
		testWorkflowA = types.SimpleNamespace(output=[self.testOutputA], run=self.runMethod)
		self.standardInpObjA = types.SimpleNamespace(workflow=testWorkflowA, label=[labelA])

		#Need to mock the fitFunction to retunr an iterable
		for idx,x in enumerate(self.standardInpObjA.workflow.output[0].stressStrainData):
			x.fitFunct.side_effect = lambda *args,**kwargs: [self.fitVals[idx]] #Just needs to be iterable

		#Also need to mock the actData to return self.actPlotData
		for idx,x in enumerate(self.standardInpObjA.workflow.output[0].stressStrainData):
			x.actVals = self.actPlotData[idx] #Mahybe sohuld be an iter or something?
    def createTestObjs(self):
        extraInfoObj = types.SimpleNamespace(
            nLayers=self.nLayers,
            lenVac=self.lenVac,
            lenAbsoluteVacuum=self.lenAbsoluteVac)
        self.testWorkflowA = mock.Mock()
        self.testWorkflowA.output = [
            types.SimpleNamespace(surfaceEnergy=self.surfEnergy,
                                  surfEPerAtom=self.ePerAtomSurf,
                                  bulkEPerAtom=self.ePerAtomBulk,
                                  extraInfo=extraInfoObj)
        ]
        testLabelA = labelHelp.StandardLabel(eleKey=self.eleKey,
                                             methodKey=self.methodStr,
                                             structKey=self.structKey)
        self.standardInpObjA = calcRunners.StandardInputObj(
            self.testWorkflowA, testLabelA)  #Dont need to set map funct

        self.testFunctA = tCode.MapSurfaceEnergiesToStandardFormat(
            xVal=self.xVal, xLabel=self.xLabel)
 def testCreateLabelAsExpected(self):
     expLabel = labelHelp.StandardLabel(eleKey=self.eleStr,
                                        structKey="eos",
                                        methodKey=self.basisAlias)
     actLabel = self.testObjA._createLabel()
     self.assertEqual(expLabel, actLabel)
 def testLabelProp(self):
     expLabel = labelHelp.StandardLabel(eleKey=self.eleKey,
                                        structKey=self.structKey,
                                        methodKey=self.methodKey)
     actLabel = self.testObjA.label
     self.assertEqual(expLabel, actLabel)
Пример #18
0
	def setUp(self):
		self.labelA = labelObjs.StandardLabel(eleKey="eleA",structKey="structA",methodKey="methB")
	def testExpectedLabelCreated(self):
		expLabel = labelHelp.StandardLabel(eleKey=self.eleKey, methodKey=self.methodKey, structKey=self.structKey)
		actLabel = self.testObjA._createLabel()
		self.assertEqual(expLabel,actLabel)