def _loadExpObjCombinedAB(self):
kwargs = {
"times": self.timesA + self.timesB,
"positions": self.positionsA + self.positionsB,
"scales": self.scalesA + self.scalesB,
"heights": self.heightsA + self.heightsB
}
return tCode.MetadynHillsInfo(**kwargs)
def createTestObjs(self):
currKwargs = {
"times": self.times,
"positions": self.positions,
"scales": self.scales,
"heights": self.heights,
"sortTimes": self.sortTimes
}
self.testObjA = tCode.MetadynHillsInfo(**currKwargs)
def createTestObjs(self):
kwargsA = {
"times": self.timesA,
"positions": self.positionsA,
"scales": self.scalesA,
"heights": self.heightsA,
"sortTimes": self.sortTimesA
}
kwargsB = {
"times": self.timesB,
"positions": self.positionsB,
"scales": self.scalesB,
"heights": self.heightsB,
"sortTimes": self.sortTimesB
}
self.testObjA = tCode.MetadynHillsInfo(**kwargsA)
self.testObjB = tCode.MetadynHillsInfo(**kwargsB)
def createTestObjs(self):
self.times = [0 for x in range(len(self.scales))]
outKwargs = {
"times": self.times,
"positions": [[x] for x in self.positions],
"scales": [[x] for x in self.scales],
"heights": [[x] for x in self.heights]
}
self.hillsObjA = aMetaHillsHelp.MetadynHillsInfo(**outKwargs)
self.expParams = [
self.positions[0], self.scales[0], self.heights[0],
self.positions[1], self.scales[1], self.heights[1]
]
def testSortTimesFunction(self):
#Figure out expected obj
expIdxOrder, kwargDict = [1, 0, 2], dict()
for attr in ["times", "positions", "scales", "heights"]:
startVals = getattr(self, attr)
kwargDict[attr] = [
copy.deepcopy(startVals[idx]) for idx in expIdxOrder
]
expObj = tCode.MetadynHillsInfo(**kwargDict)
self.assertNotEqual(expObj, self.testObjA)
self.testObjA.sortTimes()
self.assertEqual(expObj, self.testObjA)
def _loadExpectedCaseA_fromCreator(self):
expTimes = [0, 0, 20]
expPositions = self.initPositions + self.spawnedPositions
expHeights = [[h, h] for h in self.initHeights + self.spawnedHeights
] #2 values since we have 2 dimensions
expScales = self.initScales + self.spawnedScales
currKwargs = {
"times": expTimes,
"positions": expPositions,
"scales": expScales,
"heights": expHeights
}
expOutObj = aMetadynHillsHelp.MetadynHillsInfo(**currKwargs)
return expOutObj
def createTestObjs(self):
#Get the initial hills
currKwargs = {
"scales": self.initScales,
"heights": self.initHeights,
"positions": self.initPositions
}
self.spawnOptsA = mdOptsHelp.MetadynamicsSpawnHillsOptions.fromIters(
**currKwargs)
#Get the creator obj used
self.inpMetadynOpts = mdOptsHelp.MetaDynamicsOptsCP2KStandard(
None, spawnHillsOpts=self.spawnOptsA)
self.creatorObjA = creatorHelp.CP2KCalcObjFactoryStandard(
metaDynOpts=self.inpMetadynOpts)
#Get an initial object representing hills spawned
currKwargs = {
"times": self.initTimes,
"scales": self.initScales,
"heights": [[h, h] for h in self.initHeights],
"positions": self.initPositions
}
self.initHillInfoDict = aMetadynHillsHelp.MetadynHillsInfo(
**currKwargs)
#Create a mock standard output obj; need this to get the data
self.spawnedDictsA = {
"time": self.spawnedTimes,
"position": [x[0] for x in self.spawnedPositions],
"scale": [x[0] for x in self.spawnedScales],
"height": self.spawnedHeights
}
self.spawnedDictsB = {
"time": self.spawnedTimes,
"position": [x[1] for x in self.spawnedPositions],
"scale": [x[1] for x in self.spawnedScales],
"height": self.spawnedHeights
}
spawnedMetadynHillsDicts = [self.spawnedDictsA, self.spawnedDictsB]
parsedFile = types.SimpleNamespace(
metadyn_hills=spawnedMetadynHillsDicts)
outData = [[types.SimpleNamespace(parsedFile=parsedFile)]]
self.stdOutObj = types.SimpleNamespace(data=outData)
def testExpected_noInitiallySpawnedHills(self):
#get expected
expTimes = [20]
expPositions, expScales = self.spawnedPositions, self.spawnedScales
expHeights = [[h, h] for h in self.spawnedHeights]
currKwargs = {
"times": expTimes,
"positions": expPositions,
"scales": expScales,
"heights": expHeights
}
expObj = aMetadynHillsHelp.MetadynHillsInfo(**currKwargs)
#setup
self.initHillInfoDict, self.creatorObjA = None, None
#run and test
actObj = self._runTestFunct()
self.assertEqual(expObj, actObj)
def _getExpObjCaseA(self):
times, positions, scales = [
copy.deepcopy(x)
for x in [self.times, self.positions, self.scales]
]
heights = copy.deepcopy(self.heights)
positions[0].append(self.inpPosVals), positions[1].append(
self.inpPosVals)
scales[0].append(self.inpScales), scales[1].append(self.inpScales)
heights[0].append(self.heights[0][0]), heights[1].append(
self.heights[1][0])
currKwargs = {
"times": times,
"positions": positions,
"scales": scales,
"heights": heights,
"sortTimes": self.sortTimes
}
return tCode.MetadynHillsInfo(**currKwargs)
def createTestObjs(self):
self.testObjA = tCode.MetadynHillsInfo(times=self.times,
sortTimes=self.sortTimes)