def _getExpectedValsA(self):
expTrajA = trajHelp.TrajectoryInMemory(
[trajHelp.TrajStepBase(step=step) for step in [0, 1]])
expTrajB = trajHelp.TrajectoryInMemory(
[trajHelp.TrajStepBase(step=step) for step in [2, 3]])
expTrajC = trajHelp.TrajectoryInMemory(
[trajHelp.TrajStepBase(step=step) for step in [4, 5]])
return [expTrajA, expTrajB, expTrajC]
def createTestObjs(self):
self.trajA = tCode.TrajectoryInMemory(
[tCode.TrajStepBase(step=x) for x in self.stepsA])
self.trajB = tCode.TrajectoryInMemory(
[tCode.TrajStepBase(step=x) for x in self.stepsB])
self.trajC = tCode.TrajectoryInMemory(
[tCode.TrajStepBase(step=x) for x in self.stepsC])
self.trajListA = [self.trajA, self.trajB, self.trajC]
allSteps = self.stepsA + self.stepsB + self.stepsC
self.expTrajStd = tCode.TrajectoryInMemory(
[tCode.TrajStepBase(step=x) for x in allSteps])
def createTestObjs(self):
#Define some rotated water molecules
#setting up water with an angle of 90 degrees and sqrt(2) bondlengths makes this simpler
waterAzi90_pitch20 = [[0, 0, 0, "O"], [-1, 0.94, 0.34, "H"],
[1, 0.94, 0.34, "H"]] #bin [1][1]
waterAzi0_pitch20 = [[0, 0, 0, "O"], [0.94, 1.0, 0.34, "H"],
[0.94, -1, 0.34, "H"]] #bin [0][1]
waterAzi0_pitchm20 = [[0, 0, 0, "O"], [0.94, 1.0, -0.34, "H"],
[0.94, -1, -0.34, "H"]] #bin [0][0]
#Sort the trajectory; default is to use a one step trajectory
self.cellA = uCellHelp.UnitCell(lattParams=self.lattParams,
lattAngles=self.lattAngles)
self.cellA.cartCoords = waterAzi90_pitch20 + waterAzi0_pitch20 + waterAzi0_pitchm20 + waterAzi0_pitchm20
self.stepA = trajCoreHelp.TrajStepFlexible(unitCell=self.cellA)
self.trajA = trajCoreHelp.TrajectoryInMemory([self.stepA])
#Create the options objects
self.aziBins = binResHelp.BinnedResultsStandard.fromBinEdges(
self.aziEdges)
self.pitchBins = binResHelp.BinnedResultsStandard.fromBinEdges(
self.pitchEdges)
self.aziOpts = waterRotHelp.CalcStandardWaterOrientationDistribOptions(
self.aziBins, self.waterIndicesAll, angleType="azimuth")
self.pitchOpts = waterRotHelp.CalcStandardWaterOrientationDistribOptions(
self.pitchBins, self.waterIndicesAll, angleType="pitch")
def createTestObjs(self):
self.cellA = uCellHelp.UnitCell(lattParams=self.lattParams,
lattAngles=self.lattAngles)
self.cellB = uCellHelp.UnitCell(lattParams=self.lattParams,
lattAngles=self.lattAngles)
self.cellA.cartCoords = self.coordsA
self.cellB.cartCoords = self.coordsB
extraAttrDictA = {
self.velKey: {
"value": self.velsA,
"cmpType": "numericalArray"
}
}
extraAttrDictB = {
self.velKey: {
"value": self.velsB,
"cmpType": "numericalArray"
}
}
self.trajStepA = trajHelp.TrajStepFlexible(
unitCell=self.cellA, extraAttrDict=extraAttrDictA)
self.trajStepB = trajHelp.TrajStepFlexible(
unitCell=self.cellB, extraAttrDict=extraAttrDictB)
self.inpTrajA = trajHelp.TrajectoryInMemory(
[self.trajStepA, self.trajStepB])
def createTestObjs(self): #Create co-ordinates self.cellA = uCellHelp.UnitCell(lattParams=self.lattParams, lattAngles=self.lattAngles) self.cellA.cartCoords = self.coords #Create a simple one-step trajectory self.stepA = trajCoreHelp.TrajStepFlexible(unitCell=self.cellA) self.trajA = trajCoreHelp.TrajectoryInMemory([self.stepA]) #Create bins then options objects self.distBinsA = binResHelp.BinnedResultsStandard.fromBinEdges(self.distBinEdgesA) self.planarBinsA = binResHelp.BinnedResultsStandard.fromBinEdges(self.planarBinEdgesA) self.distBinsB = binResHelp.BinnedResultsStandard.fromBinEdges(self.distBinEdgesB) self.planarBinsB = binResHelp.BinnedResultsStandard.fromBinEdges(self.planarBinEdgesB) #binResObj, indicesA, indicesB, volume=None, minDistAToB=False): self.minDistsOptsA = calcDistribCoreHelp.CalcRdfOptions(self.distBinsA, self.indicesA_optsA, self.indicesB_optsA, minDistAToB=True) self.minDistsOptsB = calcDistribCoreHelp.CalcRdfOptions(self.distBinsB, self.indicesA_optsB, self.indicesB_optsB, minDistAToB=True) #binResObj, indices, planeEqn=None, volume=None): self.planarDistOptsA = calcRadImpl.CalcPlanarRdfOptions(self.planarBinsA, self.indicesA_optsA) self.planarDistOptsB = calcRadImpl.CalcPlanarRdfOptions(self.planarBinsB, self.indicesA_optsB) self.optsObjs = [ [self.minDistsOptsA, self.planarDistOptsA], [self.minDistsOptsB, self.planarDistOptsB] ]
def createTestObjs(self):
#Geom/Trajectory
self.cellA = uCellHelp.UnitCell(lattParams=self.lattParams,
lattAngles=self.lattAngles)
self.cellB = uCellHelp.UnitCell(lattParams=self.lattParams,
lattAngles=self.lattAngles)
self.cellA.cartCoords, self.cellB.cartCoords = self.coordsA, self.coordsB
trajStepA = trajCoreHelp.TrajStepFlexible(unitCell=self.cellA,
step=0,
time=10)
trajStepB = trajCoreHelp.TrajStepFlexible(unitCell=self.cellB,
step=1,
time=20)
self.traj = trajCoreHelp.TrajectoryInMemory([trajStepA, trajStepB])
#Option object
currArgs = [
self.binResObjA, self.oxyIndices, self.hyIndices,
self.distFilterIndices,
[self.distRangeA, self.distRangeB, self.distRangeC]
]
self.optObj = classDistrOptObjs.WaterCountTypesMinDistAndHBondSimpleOpts(
*currArgs)
def createTestObjs(self):
self._createCells()
self.trajStepA = trajHelp.TrajStepBase(unitCell=self.cellA,
step=self.stepA,
time=self.timeA)
trajSteps = [self.trajStepA]
self.testObjA = trajHelp.TrajectoryInMemory(trajSteps)
def createTestObjs(self):
#Geom/Trajectory
self.cellA = uCellHelp.UnitCell(lattParams=self.lattParams,
lattAngles=self.lattAngles)
self.cellB = uCellHelp.UnitCell(lattParams=self.lattParams,
lattAngles=self.lattAngles)
self.cellA.cartCoords, self.cellB.cartCoords = self.coordsA, self.coordsB
trajStepA = trajCoreHelp.TrajStepFlexible(unitCell=self.cellA,
step=0,
time=self.timeA)
trajStepB = trajCoreHelp.TrajStepFlexible(unitCell=self.cellB,
step=1,
time=self.timeB)
self.traj = trajCoreHelp.TrajectoryInMemory([trajStepA, trajStepB])
#Create the classification object options
currArgs = [[self.binResObjA], self.oxyIndices, self.hyIndices]
currKwargs = {"maxOHDist": self.maxOOHBond, "nNebs": self.nNebs}
hydroxylClassifier = classDistrOptObjs.WaterDerivativeBasedOnDistanceClassifierOptsObj(
*currArgs, **currKwargs)
#
currArgs = [
self.oxyIndices, self.hyIndices, hydroxylClassifier,
self.distrOptObjs, self.useGroups
]
currKwargs = {
"useNonHyIdx": self.useNonHyIdx,
"useIdxEach": self.useIdxEach
}
self.filteredOptObj = filteredOptObjHelp.WaterDerivativeFilteredOptsObj_simple(
*currArgs, **currKwargs)
def createTestObjs(self):
self.trajStepA = trajCoreHelp.TrajStepBase(unitCell=self.uCells[0],
step=self.steps[0])
self.trajStepB = trajCoreHelp.TrajStepBase(unitCell=self.uCells[1],
step=self.steps[1])
self.trajObjA = trajCoreHelp.TrajectoryInMemory(
[self.trajStepA, self.trajStepB])
def createTestObjs(self):
#Create thermo arrays + thermoDataObj
self.thermalArraysA = {
"step": self.steps,
"time": self.times,
"eKinetic": self.eKinetic
}
self.thermoDataA = thermoHelp.ThermoDataStandard(self.thermalArraysA)
#thngs to help mocking
trajSteps = [
trajHelp.TrajStepBase(unitCell=self.emptyCellA,
step=self.steps[0],
time=self.times[0]),
trajHelp.TrajStepBase(unitCell=self.emptyCellB,
step=self.steps[1],
time=self.times[1])
]
self.outTrajA = trajHelp.TrajectoryInMemory(trajSteps)
self.parsedCpout = {
"trajectory": self.outTrajA,
"thermo_data": self.thermoDataA,
"init_thermo_dict": self.initThermoDict,
"init_md_cell": self.initMdCell
}
self.parsedXyz = [{
"coords": self.coordsA,
"step": self.steps[0],
"time": self.times[0]
}, {
"coords": self.coordsB,
"step": self.steps[1],
"time": self.times[1]
}]
#Expected output
self.expCellA, self.expCellB = copy.deepcopy(
self.emptyCellA), copy.deepcopy(self.emptyCellB)
self.expCellA.cartCoords = self.coordsA
self.expCellB.cartCoords = self.coordsB
expTrajSteps = copy.deepcopy(trajSteps)
expTrajSteps[0].unitCell.cartCoords = self.coordsA
expTrajSteps[1].unitCell.cartCoords = self.coordsB
self.expDict = dict()
self.expDict["trajectory"] = trajHelp.TrajectoryInMemory(expTrajSteps)
self.expDict["thermo_data"] = copy.deepcopy(self.thermoDataA)
def createTestObjs(self):
#Define some rotated water molecules
#setting up water with an angle of 90 degrees and sqrt(2) bondlengths makes this simpler
waterAzi90_pitch20 = [
[0, 0, 0 + 7, "O"], [-1, 0.94, 0.34 + 7, "H"],
[1, 0.94, 0.34 + 7, "H"]
] #Translated by +7 for planar dists stuff [means dist=3]
waterAzi0_pitch20 = [[0, 0, 0 + 1, "O"], [0.94, 1.0, 0.34 + 1, "H"],
[0.94, -1, 0.34 + 1, "H"]]
waterAzi0_pitchm20 = [[0, 0, 0, "O"], [0.94, 1.0, -0.34, "H"],
[0.94, -1, -0.34, "H"]]
#Sort the trajectory; default is to use a one step trajectory
self.cellA = uCellHelp.UnitCell(lattParams=self.lattParams,
lattAngles=self.lattAngles)
self.cellA.cartCoords = waterAzi90_pitch20 + waterAzi0_pitch20 + waterAzi0_pitchm20 + waterAzi0_pitchm20
self.stepA = trajCoreHelp.TrajStepFlexible(unitCell=self.cellA)
self.trajA = trajCoreHelp.TrajectoryInMemory([self.stepA])
#Create the options objects
self.aziBinsA = binResHelp.BinnedResultsStandard.fromBinEdges(
self.aziEdgesA)
self.pitchBinsA = binResHelp.BinnedResultsStandard.fromBinEdges(
self.pitchEdgesA)
self.planarBinsA = binResHelp.BinnedResultsStandard.fromBinEdges(
self.planarEdgesA)
self.oxyDistBinsA = binResHelp.BinnedResultsStandard.fromBinEdges(
self.oxyDistEdgesA)
self.aziBinsB = binResHelp.BinnedResultsStandard.fromBinEdges(
self.aziEdgesB)
self.pitchBinsB = binResHelp.BinnedResultsStandard.fromBinEdges(
self.pitchEdgesB)
self.planarBinsB = binResHelp.BinnedResultsStandard.fromBinEdges(
self.planarEdgesB)
self.oxyDistBinsB = binResHelp.BinnedResultsStandard.fromBinEdges(
self.oxyDistEdgesB)
#Create options objs
self.aziOptsA = waterRotHelp.CalcStandardWaterOrientationDistribOptions(
self.aziBinsA, self.waterIndicesA, angleType="azimuth")
self.pitchOptsA = waterRotHelp.CalcStandardWaterOrientationDistribOptions(
self.pitchBinsA, self.waterIndicesA, angleType="pitch")
self.planarOptsA = tCode.CalcWaterPlanarDistribOptions_fromOxy(
self.planarBinsA, self.waterIndicesA)
self.oxyDistOptsA = tCode.CalcWaterOxyMinimumDistOptions(
self.oxyDistBinsA, self.waterIndicesA, self.oxyDistIndices)
self.aziOptsB = waterRotHelp.CalcStandardWaterOrientationDistribOptions(
self.aziBinsB, self.waterIndicesB, angleType="azimuth")
self.pitchOptsB = waterRotHelp.CalcStandardWaterOrientationDistribOptions(
self.pitchBinsB, self.waterIndicesB, angleType="pitch")
self.planarOptsB = tCode.CalcWaterPlanarDistribOptions_fromOxy(
self.planarBinsB, self.waterIndicesB)
self.oxyDistOptsB = tCode.CalcWaterOxyMinimumDistOptions(
self.oxyDistBinsB, self.waterIndicesB, self.oxyDistIndices)
self.optsObjs = [[self.aziOptsA, self.pitchOptsA],
[self.aziOptsB, self.pitchOptsB]]
def testInPlaceExpected(self):
self.inPlace = True
self.createView = False
expSteps = [trajHelp.TrajStepBase(step=s) for s in [0, 2, 4, 6]]
expTraj = trajHelp.TrajectoryInMemory(expSteps)
self._runTestFunct()
actTraj = self.inpTrajA
self.assertEqual(expTraj, actTraj)
def _getTrajFromStepIndices(self, stepIndices):
outSteps = list()
for idx in stepIndices:
currStepIdx, currTime = self.steps[idx], self.times[idx]
currTrajStep = trajHelp.TrajStepFlexible(step=currStepIdx,
time=currTime)
outSteps.append(currTrajStep)
return trajHelp.TrajectoryInMemory(outSteps)
def createTestObjs(self):
self.trajStepA = tCode.TrajStepBase(time=self.timeA,
step=self.stepA,
unitCell=self.unitCellA)
self.trajStepB = tCode.TrajStepBase(time=self.timeB,
step=self.stepB,
unitCell=self.unitCellA)
self.testObjA = tCode.TrajectoryInMemory(
[self.trajStepA, self.trajStepB])
def testExpectedStepsWithUnitOverlap_overlapStratSimple(self):
self.stepsA.append(4)
self.createTestObjs()
expSteps = [1, 2, 3, 4, 5, 6, 7, 8, 9]
expTraj = tCode.TrajectoryInMemory(
[tCode.TrajStepBase(step=x) for x in expSteps])
actTraj = tCode.getMergedTrajInMemory(self.trajListA,
overlapStrat="simple")
self.assertEqual(expTraj, actTraj)
def createTestObjs(self):
self.cellA = uCellHelp.UnitCell(lattParams=self.lattParamsA,
lattAngles=self.lattAnglesA)
self.cellA.cartCoords = self.cartCoordsA
trajStepA = trajCoreHelp.TrajStepFlexible(unitCell=self.cellA)
self.trajA = trajCoreHelp.TrajectoryInMemory([trajStepA])
self.binResObjA = binResHelp.BinnedResultsStandard.fromBinEdges(
self.binEdges)
def createTestObjs(self):
self.cellA = uCellHelp.UnitCell(lattParams=self.lattParams,
lattAngles=self.lattAngles)
self.cellB = uCellHelp.UnitCell(lattParams=self.lattParams,
lattAngles=self.lattAngles)
self.cellA.cartCoords, self.cellB.cartCoords = self.coordsA, self.coordsB
self.trajStepA = trajHelp.TrajStepBase(unitCell=self.cellA)
self.trajStepB = trajHelp.TrajStepBase(unitCell=self.cellB)
self.fullTrajA = trajHelp.TrajectoryInMemory(
[self.trajStepA, self.trajStepB])
def testWithNormalisedCounts(self):
""" Test that we have normalised the counts by number of steps """
self.trajA = trajCoreHelp.TrajectoryInMemory([self.stepA, self.stepA])
expBinObj = self._getExpectedBinObjCaseA()
#Note we only increase counts; NOT normalised counts
expBinObj.binVals["counts"][0][0] *= 2
expBinObj.binVals["counts"][0][1] *= 2
expBinObj.binVals["counts"][1][1] *= 2
actBinObj = self._runTestFunct()
self.assertEqual(expBinObj, actBinObj)
def createTestFunct(self):
self.stepA = trajHelp.TrajStepFlexible(step=self.steps[0],
time=self.times[0])
self.stepB = trajHelp.TrajStepFlexible(step=self.steps[1],
time=self.times[1])
self.stepC = trajHelp.TrajStepFlexible(step=self.steps[2],
time=self.times[2])
self.stepD = trajHelp.TrajStepFlexible(step=self.steps[3],
time=self.times[3])
self.allSteps = [self.stepA, self.stepB, self.stepC, self.stepD]
self.inpTraj = trajHelp.TrajectoryInMemory(self.allSteps)
def createTestObjs(self):
self.trajStepA = trajHelp.TrajStepBase(unitCell=self.unitCellA,
step=self.stepA,
time=self.timeA)
self.trajStepB = trajHelp.TrajStepBase(unitCell=self.unitCellB,
step=self.stepB,
time=self.timeB)
self.testTrajA = trajHelp.TrajectoryInMemory(
[self.trajStepA, self.trajStepB])
self.testRecord = {
self.folderKeyA: self.folderPathA,
self.fileKeyA: self.fileNameA
}
def _loadTrajInMemoryA():
outStepVals = [0, 1, 2, 3]
outTimeVals = [2, 4, 6, 8]
outGeomVals = [mock.Mock() for x in outStepVals]
outIter = [[
a, b, c
] for a, b, c in it.zip_longest(outGeomVals, outStepVals, outTimeVals)]
outTrajSteps = [
tCode.TrajStepBase(unitCell=cell, step=step, time=time)
for cell, step, time in outIter
]
return tCode.TrajectoryInMemory(outTrajSteps)
def createTestObjs(self):
self.cartXyz = [mock.Mock() for x in range(len(self.stepsXyz))]
self.cellCpout = [mock.Mock() for x in range(len(self.stepsCpout))]
self.cpoutTSteps = [
types.SimpleNamespace(step=s, time=t, unitCell=g) for s, t, g in
zip(self.stepsCpout, self.timesCpout, self.cellCpout)
]
self.parsedCpoutA = {
"trajectory": trajHelp.TrajectoryInMemory(self.cpoutTSteps)
}
self.parsedXyz = [{
"step": s,
"time": t,
"coords": g
} for s, t, g in zip(self.stepsXyz, self.timesXyz, self.cartXyz)]
def testExpectedStepsWithOverhang_trimStratSimple(self):
self.stepsA = [1, 2, 3, 4, 5]
self.stepsB = [
4, 6
] #Deleting step 5 makes it more likely we really are taking the step 4 from this set of trajs
self.stepsC = [7, 8, 9]
self.createTestObjs()
expSteps = [1, 2, 3, 4, 6, 7, 8, 9]
expTraj = tCode.TrajectoryInMemory(
[tCode.TrajStepBase(step=x) for x in expSteps])
actTraj = tCode.getMergedTrajInMemory(self.trajListA,
overlapStrat="simple",
trimStrat="simple")
self.assertEqual(expTraj, actTraj)
def createTestObjs(self):
self.thermoDataA = thermoHelp.ThermoDataStandard({"step": self.stepsA})
self.thermoDataB = thermoHelp.ThermoDataStandard({"step": self.stepsB})
self.trajA = trajHelp.TrajectoryInMemory(
[trajHelp.TrajStepBase(step=x) for x in self.stepsA])
self.trajB = trajHelp.TrajectoryInMemory(
[trajHelp.TrajStepBase(step=x) for x in self.stepsB])
self.retDictA = {
"trajectory": self.trajA,
"thermo_data": self.thermoDataA
}
self.retDictB = {
"trajectory": self.trajB,
"thermo_data": self.thermoDataB
}
self.expThermoData = thermoHelp.ThermoDataStandard(
{"step": self.stepsA + self.stepsB})
self.expTraj = trajHelp.TrajectoryInMemory(
[trajHelp.TrajStepBase(step=x) for x in self.stepsA + self.stepsB])
self.expDictA = {
"trajectory": self.expTraj,
"thermo_data": self.expThermoData
}
def createTestObjs(self):
self.stepA = trajHelp.TrajStepFlexible(time=self.times[0],
extraAttrDict={
self.atomTempKey: {
"value": self.tempsA,
"cmpType":
"numericalArray"
}
})
self.stepB = trajHelp.TrajStepFlexible(time=self.times[1],
extraAttrDict={
self.atomTempKey: {
"value": self.tempsB,
"cmpType":
"numericalArray"
}
})
self.trajA = trajHelp.TrajectoryInMemory([self.stepA, self.stepB])
def createTestObjs(self):
#Create the trajectory
self.cellA = uCellHelp.UnitCell(lattParams=self.lattParams,
lattAngles=self.lattAngles)
self.cellA.cartCoords = self.cartCoords
self.trajStepA = trajCoreHelp.TrajStepFlexible(unitCell=self.cellA)
self.traj = trajCoreHelp.TrajectoryInMemory([self.trajStepA])
#Create two options objs
self.binsA = binResHelp.BinnedResultsStandard.fromBinEdges(
self.binEdgesA)
self.binsB = binResHelp.BinnedResultsStandard.fromBinEdges(
self.binEdgesB)
self.optsA = tCode.CalcStandardWaterOrientationDistribOptions(
self.binsA, self.indicesA, angleType=self.angleTypeA)
self.optsB = tCode.CalcStandardWaterOrientationDistribOptions(
self.binsB, self.indicesB, angleType=self.angleTypeB)
def testExpectedTrajReturnedA(self, mockGetFileList): #Set out mock mockGetFileList.side_effect = lambda *args,**kwargs: self.fileListA #Figure out expected trajectory cellA = uCellHelp.UnitCell.fromLattVects([[6.06,0,0],[-3, 5.2, 0], [0, 0, 9.8]]) cellB = uCellHelp.UnitCell.fromLattVects([[5,0,0], [0,6,0], [0,0,7]]) coordsA = [ [1,1,1,"Mg"], [3,3,3,"X"] ] coordsB = [ [2,3,4,"Mg"], [4,5,6,"X"] ] cellA.cartCoords, cellB.cartCoords = coordsA, coordsB stepA = trajHelp.TrajStepBase(unitCell=cellA) stepB = trajHelp.TrajStepBase(unitCell=cellB) expTraj = trajHelp.TrajectoryInMemory([stepA,stepB]) #Run + test actTraj = tCode.readTrajFromSimpleExtendedXyzFormat(self.inpPathA) mockGetFileList.assert_called_with(self.inpPathA) self.assertEqual(expTraj,actTraj)
def _mdStepsFinalStepFunct(parserInstance):
outThermoDict = parserInstance.outDict["thermo_arrays"]
parserInstance.outDict["thermo_data"] = thermoDataHelp.ThermoDataStandard(
outThermoDict)
trajSteps = list()
thermoInfo = parserInstance.outDict["thermo_arrays"]
assert len(thermoInfo["step"]) == len(parserInstance.outDict["traj_geoms"])
for idx, geom in enumerate(parserInstance.outDict["traj_geoms"]):
# currStep = trajHelp.TrajStepBase(unitCell=geom, step=thermoInfo["step"][idx], time=thermoInfo["time"][idx])
currStep = trajHelp.TrajStepFlexible(unitCell=geom,
step=thermoInfo["step"][idx],
time=thermoInfo["time"][idx])
trajSteps.append(currStep)
parserInstance.outDict["trajectory"] = trajHelp.TrajectoryInMemory(
trajSteps)
parserInstance.outDict.pop("thermo_arrays")
parserInstance.outDict.pop("traj_geoms")
def _getMergedTrajectoryFromParsedCpoutAndXyz(parsedCpout, parsedXyz):
trajCpout, trajXyz = parsedCpout["trajectory"].trajSteps, parsedXyz
outList = list()
# assert len(trajXyz)>=len(trajCpout)
idxCpout, idxXyz = 0, 0
#Will throw an index error if we reach the end of cpout without finding the expected unit cell
while idxXyz < len(parsedXyz):
while idxCpout < len(trajCpout):
if (trajCpout[idxCpout].step == parsedXyz[idxXyz]["step"]):
trajCpout[idxCpout].unitCell.cartCoords = parsedXyz[idxXyz][
"coords"]
outList.append(trajCpout[idxCpout])
break
else:
idxCpout += 1
idxXyz += 1
return trajHelp.TrajectoryInMemory(outList)
def _loadExpectedObjsForFullStrA(self): lattVectsBoth = [ [9.63 , 0 , 0 ], [-4.81018, 8.33982, 0 ], [0 , 0 , 17.87895] ] cartCoordsA = [ [0.40125, 2.08496, 1.11743, "1"], [0.0226 , 3.0105 , 1.11743, "2"], [1.39212, 2.21981, 1.11743, "2"], [3.61125, 2.08496, 1.11743, "1"], [3.2326 , 3.0105 , 1.11743, "2"], [4.60212, 2.21981, 1.11743, "2"] ] cartCoordsB = [ [-0.426578, 1.73786, 0.96724 ,"1"], [0.148568 , 2.48075, 1.30372 ,"2"], [-1.43515 , 1.8717 , 1.23895 ,"2"], [4.47632 , 2.423 , 0.945189,"1"], [3.6439 , 2.54601, 1.57979 ,"2"], [4.44324 , 1.45043, 0.686697,"2"] ] if self.typeIdxToEle is not None: for idx,vals in enumerate(cartCoordsA): cartCoordsA[idx][-1] = self.typeIdxToEle[ cartCoordsA[idx][-1] ] for idx,vals in enumerate(cartCoordsB): cartCoordsB[idx][-1] = self.typeIdxToEle[ cartCoordsB[idx][-1] ] self.cellA = uCellHelp.UnitCell.fromLattVects(lattVectsBoth) self.cellB = uCellHelp.UnitCell.fromLattVects(lattVectsBoth) self.cellA.cartCoords = cartCoordsA self.cellB.cartCoords = cartCoordsB if self.timeStep is None: self.trajStepA = trajObjHelp.TrajStepBase(unitCell=self.cellA, step=0 , time=None) self.trajStepB = trajObjHelp.TrajStepBase(unitCell=self.cellB, step=50, time=None) else: self.trajStepA = trajObjHelp.TrajStepBase(unitCell=self.cellA, step=0 , time=0) self.trajStepB = trajObjHelp.TrajStepBase(unitCell=self.cellB, step=50, time=50*self.timeStep) self.expTrajObjA = trajObjHelp.TrajectoryInMemory([self.trajStepA, self.trajStepB])
