PyFoam.Infrastructure.CTestRun module

A wrapper to run a solver as a CTest

class PyFoam.Infrastructure.CTestRun.CTestRun(*args, **kwargs)

Bases: object

This class runs a solver on a test case, examines the results and fails if they don’t live up the expectations

__dict__ = mappingproxy({'__module__': 'PyFoam.Infrastructure.CTestRun', '__doc__': "This class runs a solver on a test case, examines the results\n    and fails if they don't live up the expectations", '__init__': <function CTestRun.__init__>, '__new__': <staticmethod(<function CTestRun.__new__>)>, '_CTestRun__recursiveInit': <function CTestRun.__recursiveInit>, 'addToClone': <function CTestRun.addToClone>, 'setParameters': <function CTestRun.setParameters>, 'parameterValues': <function CTestRun.parameterValues>, '_CTestRun__setParameterAsUsed': <function CTestRun.__setParameterAsUsed>, '__getitem__': <function CTestRun.__getitem__>, 'shortTestName': <function CTestRun.shortTestName>, 'testName': <function CTestRun.testName>, 'timeoutDefinitions': [('unknown', 60), ('tiny', 60), ('small', 300), ('medium', 1800), ('big', 7200), ('huge', 43200), ('monster', 172800), ('unlimited', 2592000)], 'sizeClassString': <function CTestRun.sizeClassString>, 'setTimeout': <function CTestRun.setTimeout>, '_CTestRun__doInit': <function CTestRun.__doInit>, 'readRunInfo': <function CTestRun.readRunInfo>, 'writeRunInfo': <function CTestRun.writeRunInfo>, 'wrapACallback': <function CTestRun.wrapACallback>, 'wrapCallbacks': <function CTestRun.wrapCallbacks>, 'processOptions': <function CTestRun.processOptions>, 'run': <function CTestRun.run>, 'workDir': <function CTestRun.workDir>, 'dataDir': <function CTestRun.dataDir>, 'addFunctionObjects': <function CTestRun.addFunctionObjects>, 'cloneData': <function CTestRun.cloneData>, 'runCommand': <function CTestRun.runCommand>, 'shell': <function CTestRun.shell>, 'execute': <function CTestRun.execute>, 'runInfo': <function CTestRun.runInfo>, 'solution': <function CTestRun.solution>, 'controlDict': <function CTestRun.controlDict>, 'line': <function CTestRun.line>, 'status': <function CTestRun.status>, 'messageGeneral': <function CTestRun.messageGeneral>, 'failGeneral': <function CTestRun.failGeneral>, 'warn': <function CTestRun.warn>, 'fail': <function CTestRun.fail>, 'fatalFail': <function CTestRun.fatalFail>, 'endTest': <function CTestRun.endTest>, 'which': <function CTestRun.which>, 'runAndCatchExceptions': <function CTestRun.runAndCatchExceptions>, 'runTests': <function CTestRun.runTests>, 'generalTest': <function CTestRun.generalTest>, 'compareSamples': <function CTestRun.compareSamples>, 'compareTimelines': <function CTestRun.compareTimelines>, 'isNotEqual': <function CTestRun.isNotEqual>, 'isEqual': <function CTestRun.isEqual>, 'isBigger': <function CTestRun.isBigger>, 'isSmaller': <function CTestRun.isSmaller>, 'preRunTestCheckMesh': <function CTestRun.preRunTestCheckMesh>, 'autoDecompose': <function CTestRun.autoDecompose>, 'autoReconstruct': <function CTestRun.autoReconstruct>, 'meshPrepare': <function CTestRun.meshPrepare>, 'casePrepare': <function CTestRun.casePrepare>, 'parallelPrepare': <function CTestRun.parallelPrepare>, 'postprocess': <function CTestRun.postprocess>, 'decompose': <function CTestRun.decompose>, 'reconstruct': <function CTestRun.reconstruct>, '__dict__': <attribute '__dict__' of 'CTestRun' objects>, '__weakref__': <attribute '__weakref__' of 'CTestRun' objects>, '__annotations__': {}})

__doInit(solver, originalCase, minimumRunTime=None, referenceData=None, tailLength=50, headLength=50, **kwargs)

Initialzation method to be called before running the actual test (purpose of this method is to avoid cascaded of constructor-calls

Parameters:

• solver – name of the solver to test

• originalCase – location of the original case files (they

will be copied) :param minimumRuntime: the solver has to run at least to this time to be considered “ran successful” :param referenceData: directory with data that is used for testing :param tailLength: output that many lines from the end of the solver output :param headLength: output that many lines from the beginning of the solver output

__getitem__(key)

Get a parameter

__init__()

__module__ = 'PyFoam.Infrastructure.CTestRun'

static __new__(cls, *args, **kwargs)

__recursiveInit(theClass, called)

Automatically call the ‘init’-method of the whole tree

__setParameterAsUsed(keys)

__weakref__

list of weak references to the object (if defined)

addFunctionObjects(templateFile)

Add entries for libraries and functionObjects to the controlDict (if they don’t exist :param templateFile: file withe the data that should be added

addToClone(*args)

autoDecompose()

Decomposition used if no callback is specified

autoReconstruct()

Reconstruction used if no callback is specified

casePrepare()

Callback to prepare the case. Default behaviour is to do nothing

cloneData(src, dst)

Copy files recurivly into a case :param src: the source directory the files come fro :param dst: the destination directory the files go to

compareSamples(data, reference, fields, time=None, line=None, scaleData=1, offsetData=0, scaleX=1, offsetX=0, useReferenceForComparison=False)

Compare sample data and return the statistics :param data: the name of the data directory :param reference:the name of the directory with the reference data :param fields: list of the fields to compare :param time: the time to compare for. If empty the latest time is used

compareTimelines(data, reference, fields)

Compare timeline data and return the statistics :param data: the name of the data directory :param reference:the name of the directory with the reference data :param fields: list of the fields to compare

controlDict()

Access a representation of the controlDict of the case

dataDir()

decompose()

Callback to do the decomposition (if automatic is not sufficient)

endTest()

execute(*args, **kwargs)

Execute the passed arguments on the case and check if everything went alright :param regexps: a list of regular expressions that the output should be scanned for

fail(*args)

To be called if the test failed but other tests should be tried :param args: arbitrary number of arguments that build the fail-message

failGeneral(prefix, *args)

Parameters:

args – arbitrary number of arguments that build the

fail-message :param prefix: General classification of the failure

fatalFail(*args)

Parameters:

args – arbitrary number of arguments that build the

fail-message

generalTest(testFunction, args, *message)

isBigger(value, threshold=0, message='')

isEqual(value, target=0, tolerance=1e-10, message='')

isNotEqual(value, target=0, tolerance=1e-10, message='')

isSmaller(value, threshold=0, message='')

line()

meshPrepare()

Callback to prepare the mesh for the case. Default behaviour is to run blockMesh on the case

messageGeneral(prefix, say, *args)

Everything that passes through this method will be repeated in the end :param args: arbitrary number of arguments that build the fail-message :param prefix: General classification of the message

parallelPrepare()

Callback to prepare the case in parallel (after it was decomposed). Default behaviour is to do nothing

parameterValues()

postprocess()

Callback to run after the solver has finished. Default behaviour is to do nothing

preRunTestCheckMesh()

This test is always run. If this is not desirable it has to be overridden in a child-class

processOptions()

Select which phase of the test should be run

readRunInfo()

read the runInfo from a file

reconstruct()

Callback to do the reconstruction (if automatic is not sufficient)

run()

Run the actual test

runAndCatchExceptions(func, *args, **kwargs)

Run a callable and catch Python-exceptions if they occur :param func: The actual thing to be run

runCommand(*args)

Run a command and let it directly write to the output

runInfo()

return the run information. If the solver was actually run

runTests(namePrefix, warnSerial=False)

Run all methods that fit a certain name prefix

setParameters(**kwargs)

Update the parameters with a set of keyword-arguments

setTimeout(quiet=False)

shell(*args)

Run a command in the case directory and let it directly write to the output :param workingDirectory: change to this directory

shortTestName()

sizeClassString()

solution()

Access to a SolutionDirectory-object that represents the current solution

status(*args)

print a status message about the test

testName()

Return the full test name with which this test is identified

timeoutDefinitions = [('unknown', 60), ('tiny', 60), ('small', 300), ('medium', 1800), ('big', 7200), ('huge', 43200), ('monster', 172800), ('unlimited', 2592000)]

warn(*args)

Parameters:

args – arbitrary number of arguments that build the

warning-message

which(command)

Like the regular which command - return the full path to an executable

workDir()

wrapACallback(name)

Has to be a separate method because the loop in wrapCallbacks didn’t work

wrapCallbacks()

Wrap the callback methods with a Python exception handler. This is not done here so that methoids that the child classes overwrote will be wrapped to

writeRunInfo()

read the runInfo from a file

PyFoam.Infrastructure.CTestRun.isCallback(f)