PyFoam.RunDictionary.ParsedParameterFile module

Parameter file is read into memory and modified there

exception PyFoam.RunDictionary.ParsedParameterFile.BinaryParserError(descr, data=None)

Bases: PyFoamParserError

__annotations__ = {}

__init__(descr, data=None)

__module__ = 'PyFoam.RunDictionary.ParsedParameterFile'

class PyFoam.RunDictionary.ParsedParameterFile.Enumerate(names)

Bases: object

__dict__ = mappingproxy({'__module__': 'PyFoam.RunDictionary.ParsedParameterFile', '__init__': <function Enumerate.__init__>, '__dict__': <attribute '__dict__' of 'Enumerate' objects>, '__weakref__': <attribute '__weakref__' of 'Enumerate' objects>, '__doc__': None, '__annotations__': {}})

__init__(names)

__module__ = 'PyFoam.RunDictionary.ParsedParameterFile'

__weakref__

list of weak references to the object (if defined)

class PyFoam.RunDictionary.ParsedParameterFile.FoamFileParser(content, fName=None, debug=False, noHeader=False, noBody=False, doMacroExpansion=False, boundaryDict=False, preserveComments=True, preserveNewlines=True, listDict=False, listDictWithHeader=False, listLengthUnparsed=None, binaryMode=False, treatBinaryAsASCII=False, duplicateCheck=False, noVectorOrTensor=False, dictStack=None, duplicateFail=True)

Bases: PlyParser

Class that parses a string that contains the contents of an OpenFOAM-file and builds a nested structure of directories and lists from it

__annotations__ = {}

__contains__(key)

__delitem__(key)

__getitem__(key)

__init__(content, fName=None, debug=False, noHeader=False, noBody=False, doMacroExpansion=False, boundaryDict=False, preserveComments=True, preserveNewlines=True, listDict=False, listDictWithHeader=False, listLengthUnparsed=None, binaryMode=False, treatBinaryAsASCII=False, duplicateCheck=False, noVectorOrTensor=False, dictStack=None, duplicateFail=True)

Parameters:

• content – the string to be parsed

• fName – Name of the actual file (if any)

• debug – output debug information during parsing

• noHeader – switch that turns off the parsing of the header

• duplicateCheck – Check for duplicates in dictionaries

• duplicateFail – Fail if a duplicate is discovered

__iter__()

__module__ = 'PyFoam.RunDictionary.ParsedParameterFile'

__setitem__(key, value)

addCommentToDecorations(text)

addNewlinesToDecorations(text)

addToDecoration(text)

condenseAllPreFixLists(orig)

Checks whether this list is a list that consists only of prefix-Lists

directory()

getData()

Get the data structure

getDecoration()

getHeader()

Get the OpenFOAM-header

literals = '(){};[]^'

p_afterHeader(p)

afterHeader :

p_binaryblob(p)

binaryblob : BINARYBLOB

p_boundaryDict(p)

boundaryDict : header list | header prelist

p_codeSeen(p)

codeSeen :

p_codestream(p)

codestream : codeSeen CODESTART CODESTREAMCHUNK CODEEND

p_dictbody(p)

dictbody : dictbody dictline | dictline | empty

p_dictionary(p)

dictionary : ‘{’ enter_dict dictbody ‘}’ exit_dict | ‘{’ ‘}’

p_dictitem(p)

dictitem : longitem | pitem

p_dictkey(p)

dictkey : word | SCONST

p_dictline(p)

dictline : dictkey dictitem ‘;’ | dictkey list ‘;’ | dictkey prelist ‘;’ | dictkey uniformfield ‘;’ | dictkey fieldvalue ‘;’ | macro | substitution ‘;’ | dictkey codestream ‘;’ | dictkey dictionary | ‘;’

p_dimension(p)

dimension : ‘[’ number number number number number number number ‘]’ | ‘[’ number number number number number ‘]’ | ‘[’ symbolic_dimension ‘]’

p_empty(p)

empty :

p_enter_dict(p)

enter_dict :

p_error(p)

p_exit_dict(p)

exit_dict :

p_fieldvalue_nonuniform(p)

fieldvalue : NONUNIFORM NAME list | NONUNIFORM prelist | NONUNIFORM NAME prelist

p_fieldvalue_uniform(p)

fieldvalue : UNIFORM number | UNIFORM vector | UNIFORM tensor | UNIFORM symmtensor

p_float(p)

float : FCONST

p_global(p)

global : header dictbody

p_gotHeader(p)

gotHeader :

p_header(p)

header : FOAMFILE dictionary

p_ignore_rest_of_line(p)

ignore_rest_of_line :

p_include(p)

include : INCLUDE SCONST ignore_rest_of_line | INCLUDE_ETC SCONST ignore_rest_of_line | INCLUDE_FUNC NAME ignore_rest_of_line | INCLUDE_FUNC SCONST ignore_rest_of_line | INCLUDEIFPRESENT SCONST ignore_rest_of_line

p_inputMode(p)

inputMode : INPUTMODE ignore_rest_of_line ERROR | INPUTMODE ignore_rest_of_line WARN | INPUTMODE ignore_rest_of_line PROTECT | INPUTMODE ignore_rest_of_line DEFAULT | INPUTMODE ignore_rest_of_line MERGE | INPUTMODE ignore_rest_of_line OVERWRITE

p_integer(p)

integer : ICONST

p_item(p)

item : pitem | REACTION | prelist | list | uniformfield | dictionary

p_itemlist(p)

itemlist : itemlist item | itemlist ‘;’ | item

p_list(p)

list : ‘(’ itemlist ‘)’

p_longitem(p)

longitem : pitemlist pitem

p_macro(p)

macro : KANALGITTER include RESTOFLINE | KANALGITTER inputMode RESTOFLINE | KANALGITTER remove RESTOFLINE

p_noBody(p)

noBody : FOAMFILE ‘{’ dictbody gotHeader ‘}’

p_noHeader(p)

noHeader : dictbody

p_number(p)

number : integer | FCONST

p_onlyListOrPList(p)

onlyListOrPList : list | prelist | uniformfield

p_pitem(p)

pitem : word | SCONST | number | dictionary | list | dimension | substitution | empty

p_pitemlist(p)

pitemlist : pitemlist pitem | pitem

p_prelist(p)

prelist : integer prelist_seen ‘(’ itemlist ‘)’ | integer prelist_seen ‘(’ binaryblob ‘)’ | integer prelist_seen ‘(’ unparsed ‘)’ | integer prelist_seen ‘{’ item ‘}’

p_prelist_seen(p)

prelist_seen :

p_pureList(p)

pureList : onlyListOrPList

p_pureListWithHeader(p)

pureListWithHeader : header onlyListOrPList

p_remove(p)

remove : REMOVE ignore_rest_of_line word | REMOVE wlist

p_substitution(p)

substitution : SUBSTITUTION

p_symbolic_dimension(p)

symbolic_dimension : symbolic_dimension_terminal symbolic_dimension | symbolic_dimension_terminal

p_symbolic_dimension_terminal(p)

symbolic_dimension_terminal : word | number | ‘(’ | ‘)’ | ‘*’ | ‘/’ | ‘^’

p_symmtensor(p)

symmtensor : ‘(’ number number number number number number ‘)’

p_tensor(p)

tensor : ‘(’ number number number number number number number number number ‘)’

p_uniformfield(p)

uniformfield : integer ‘{’ number ‘}’ | integer ‘{’ vector ‘}’ | integer ‘{’ tensor ‘}’ | integer ‘{’ symmtensor ‘}’

p_unparsed(p)

unparsed : UNPARSEDCHUNK

p_vector(p)

vector : ‘(’ number number number ‘)’

p_wlist(p)

wlist : ‘(’ wordlist ignore_rest_of_line ‘)’

p_word(p)

word : NAME | UNIFORM | NONUNIFORM | MERGE | OVERWRITE | DEFAULT | WARN | PROTECT | ERROR

p_wordlist(p)

wordlist : wordlist word | word

parseSubst_root(nm, stck)

parserError(text, c, ind)

Prints the error message of the parser and exit

printContext(c, ind)

Prints the context of the current index

reserved = {'FoamFile': 'FOAMFILE', 'default': 'DEFAULT', 'error': 'ERROR', 'include': 'INCLUDE', 'includeEtc': 'INCLUDE_ETC', 'includeFunc': 'INCLUDE_FUNC', 'includeIfPresent': 'INCLUDEIFPRESENT', 'inputMode': 'INPUTMODE', 'merge': 'MERGE', 'nonuniform': 'NONUNIFORM', 'overwrite': 'OVERWRITE', 'protect': 'PROTECT', 'remove': 'REMOVE', 'sinclude': 'INCLUDEIFPRESENT', 'uniform': 'UNIFORM', 'warn': 'WARN'}

resetDecoration()

states = (('unparsed', 'exclusive'), ('codestream', 'exclusive'), ('mlcomment', 'exclusive'), ('binaryblob', 'exclusive'), ('ignorerestofline', 'exclusive'))

t_CODEEND = '\\#\\}'

t_CODESTART = '\\#\\{'

t_FCONST = '(-|)((\\d+)(\\.\\d*)([eE](\\+|-)?(\\d+))? | (\\d+)[eE](\\+|-)?(\\d+))([lL]|[fF])?'

t_ICONST = '(-|)\\d+([uU]|[lL]|[uU][lL]|[lL][uU])?'

t_KANALGITTER = '\\#'

t_NAME(t)

[a-zA-Z_][+-<>(),.*|a-zA-Z_0-9&%:]*

t_SCONST = '\\"([^\\\\\\n]|(\\\\.))*?\\"'

t_SUBSTITUITION(t)

$[a-zA-Z_.:{][+-<>(),.*|a-zA-Z_0-9&%:${}]*

t_binaryblob_close(t)

)

t_binaryblob_error(t)

t_binaryblob_ignore = ''

t_binaryblob_throwaway(t)

[^)]

t_ccode_comment(t)

//.*

t_codestream_end(t)

#}

t_codestream_error(t)

t_codestream_ignore = ''

t_codestream_throwaway(t)

[^#]

t_error(t)

t_ignore = ' \t\r'

t_ignorerestofline_SCONST(t)

"([^\n]|(\.))*?"

t_ignorerestofline_error(t)

t_ignorerestofline_ignore = ''

t_ignorerestofline_newline(t)

[n]

t_ignorerestofline_restofline(t)

[^n]+

t_mlcomment_endcomment(t)

*/

t_mlcomment_error(t)

t_mlcomment_ignore = ''

t_mlcomment_newlevel(t)

/*

t_mlcomment_throwaway(t)

[^*]

t_newline(t)

n+

t_startmlcomment(t)

/*

t_unparsed_error(t)

t_unparsed_ignore = ' \t\n0123456789.-+e'

t_unparsed_left(t)

(

t_unparsed_right(t)

)

tokens = ('NAME', 'ICONST', 'FCONST', 'SCONST', 'FOAMFILE', 'UNIFORM', 'NONUNIFORM', 'UNPARSEDCHUNK', 'CODESTREAMCHUNK', 'REACTION', 'SUBSTITUTION', 'MERGE', 'OVERWRITE', 'ERROR', 'WARN', 'PROTECT', 'DEFAULT', 'INCLUDE', 'INCLUDE_ETC', 'INCLUDE_FUNC', 'INCLUDEIFPRESENT', 'REMOVE', 'INPUTMODE', 'KANALGITTER', 'CODESTART', 'CODEEND', 'BINARYBLOB', 'RESTOFLINE')

class PyFoam.RunDictionary.ParsedParameterFile.FoamStringParser(content, debug=False, noVectorOrTensor=False, duplicateCheck=False, listDict=False, doMacroExpansion=False, duplicateFail=False)

Bases: FoamFileParser

Convenience class that parses only a headerless OpenFOAM dictionary

__annotations__ = {}

__init__(content, debug=False, noVectorOrTensor=False, duplicateCheck=False, listDict=False, doMacroExpansion=False, duplicateFail=False)

Parameters:

• content – the string to be parsed

• debug – output debug information during parsing

__module__ = 'PyFoam.RunDictionary.ParsedParameterFile'

__str__()

Return str(self).

class PyFoam.RunDictionary.ParsedParameterFile.NotAPrelist(a, b)

Bases: object

Class to return if the length of the prelist does not fit the prefix

__dict__ = mappingproxy({'__module__': 'PyFoam.RunDictionary.ParsedParameterFile', '__doc__': 'Class to return if the length of the prelist does not fit the prefix', '__init__': <function NotAPrelist.__init__>, '__dict__': <attribute '__dict__' of 'NotAPrelist' objects>, '__weakref__': <attribute '__weakref__' of 'NotAPrelist' objects>, '__annotations__': {}})

__init__(a, b)

__module__ = 'PyFoam.RunDictionary.ParsedParameterFile'

__weakref__

list of weak references to the object (if defined)

class PyFoam.RunDictionary.ParsedParameterFile.ParsedBoundaryDict(name, treatBinaryAsASCII=False, backup=False, debug=False)

Bases: ParsedParameterFile

Convenience class that parses only a OpenFOAM polyMesh-boundaries file

__annotations__ = {}

__init__(name, treatBinaryAsASCII=False, backup=False, debug=False)

Parameters:

• name – The name of the parameter file

• backup – create a backup-copy of the file

__module__ = 'PyFoam.RunDictionary.ParsedParameterFile'

__str__()

Generates a string from the contents in memory Used to be called makeString

parse(content)

Constructs a representation of the file

class PyFoam.RunDictionary.ParsedParameterFile.ParsedFileHeader(name)

Bases: ParsedParameterFile

Only parse the header of a file

__annotations__ = {}

__contains__(name)

__getitem__(name)

__init__(name)

Parameters:

• name – The name of the parameter file

• backup – create a backup-copy of the file

• boundaryDict – the file to parse is a boundary file

• listDict – the file only contains a list

• listDictWithHeader – the file only contains a list and a header

• listLengthUnparsed – Lists longer than that length are not parsed

• binaryMode – Parse long lists in binary mode (to be overridden by

the settings in the header). :param treatBinaryAsASCII: even if the header says that this is a binary file treat it like an ASCII-file :param noHeader: don’t expect a header :param noBody: don’t read the body of the file (only the header) :param doMacroExpansion: expand #include and $var :param noVectorOrTensor: short lists of length 3, 6 an 9 are NOT interpreted as vectors or tensors :param dontRead: Do not read the file during construction :param longListOutputThreshold: Lists that are longer than this are prefixed with a length :param dictStack: dictionary stack for lookup (only used for include)

__len__()

__module__ = 'PyFoam.RunDictionary.ParsedParameterFile'

class PyFoam.RunDictionary.ParsedParameterFile.ParsedParameterFile(name, backup=False, debug=False, boundaryDict=False, listDict=False, listDictWithHeader=False, listLengthUnparsed=None, preserveComments=True, noHeader=False, binaryMode=False, treatBinaryAsASCII=False, noBody=False, doMacroExpansion=False, dontRead=False, noVectorOrTensor=False, dictStack=None, createZipped=True, longListOutputThreshold=20)

Bases: FileBasisBackup

Parameterfile whose complete representation is read into memory, can be manipulated and afterwards written to disk

__annotations__ = {}

__contains__(key)

__delitem__(key)

__getitem__(key)

__init__(name, backup=False, debug=False, boundaryDict=False, listDict=False, listDictWithHeader=False, listLengthUnparsed=None, preserveComments=True, noHeader=False, binaryMode=False, treatBinaryAsASCII=False, noBody=False, doMacroExpansion=False, dontRead=False, noVectorOrTensor=False, dictStack=None, createZipped=True, longListOutputThreshold=20)

Parameters:

• name – The name of the parameter file

• backup – create a backup-copy of the file

• boundaryDict – the file to parse is a boundary file

• listDict – the file only contains a list

• listDictWithHeader – the file only contains a list and a header

• listLengthUnparsed – Lists longer than that length are not parsed

• binaryMode – Parse long lists in binary mode (to be overridden by

the settings in the header). :param treatBinaryAsASCII: even if the header says that this is a binary file treat it like an ASCII-file :param noHeader: don’t expect a header :param noBody: don’t read the body of the file (only the header) :param doMacroExpansion: expand #include and $var :param noVectorOrTensor: short lists of length 3, 6 an 9 are NOT interpreted as vectors or tensors :param dontRead: Do not read the file during construction :param longListOutputThreshold: Lists that are longer than this are prefixed with a length :param dictStack: dictionary stack for lookup (only used for include)

__iter__()

__len__()

__module__ = 'PyFoam.RunDictionary.ParsedParameterFile'

__setitem__(key, value)

__str__()

Generates a string from the contents in memory Used to be called makeString

getValueDict()

Get a dictionary with the values with the decorators removed

parse(content)

Constructs a representation of the file

exception PyFoam.RunDictionary.ParsedParameterFile.PyFoamParserError(descr, data=None)

Bases: FatalErrorPyFoamException

__annotations__ = {}

__init__(descr, data=None)

__module__ = 'PyFoam.RunDictionary.ParsedParameterFile'

__repr__()

Return repr(self).

__str__()

Return str(self).

class PyFoam.RunDictionary.ParsedParameterFile.WriteParameterFile(name, backup=False, className='dictionary', objectName=None, createZipped=False, **kwargs)

Bases: ParsedParameterFile

A specialization that is used to only write to the file

__annotations__ = {}

__init__(name, backup=False, className='dictionary', objectName=None, createZipped=False, **kwargs)

Parameters:

• name – The name of the parameter file

• backup – create a backup-copy of the file

• boundaryDict – the file to parse is a boundary file

• listDict – the file only contains a list

• listDictWithHeader – the file only contains a list and a header

• listLengthUnparsed – Lists longer than that length are not parsed

• binaryMode – Parse long lists in binary mode (to be overridden by

the settings in the header). :param treatBinaryAsASCII: even if the header says that this is a binary file treat it like an ASCII-file :param noHeader: don’t expect a header :param noBody: don’t read the body of the file (only the header) :param doMacroExpansion: expand #include and $var :param noVectorOrTensor: short lists of length 3, 6 an 9 are NOT interpreted as vectors or tensors :param dontRead: Do not read the file during construction :param longListOutputThreshold: Lists that are longer than this are prefixed with a length :param dictStack: dictionary stack for lookup (only used for include)

__module__ = 'PyFoam.RunDictionary.ParsedParameterFile'