def additionalReconstruct(self,parameters):
     sol=SolutionDirectory(self.casename())
     if len(sol.processorDirs())>0:
         for t in listdir(path.join(self.casename(),sol.processorDirs()[0])):
             try:
                 tm=float(t)
                 self.foamRun("reconstructParMesh",foamArgs=["-time",t])
                 self.foamRun("reconstructPar",foamArgs=["-time",t])
             except ValueError:
                 print "Skipping",t
Exemple #2
0
 def additionalReconstruct(self, parameters):
     sol = SolutionDirectory(self.casename())
     if len(sol.processorDirs()) > 0:
         for t in listdir(path.join(self.casename(),
                                    sol.processorDirs()[0])):
             try:
                 tm = float(t)
                 self.foamRun("reconstructParMesh", foamArgs=["-time", t])
                 self.foamRun("reconstructPar", foamArgs=["-time", t])
             except ValueError:
                 print "Skipping", t
Exemple #3
0
    def doRegion(self, theRegion):
        ReST = RestructuredTextHelper(defaultHeading=self.opts.headingLevel)

        if self.opts.allRegions:
            print_(
                ReST.buildHeading("Region: ",
                                  theRegion,
                                  level=self.opts.headingLevel - 1))

        sol = SolutionDirectory(self.parser.getArgs()[0],
                                archive=None,
                                parallel=self.opts.parallel,
                                paraviewLink=False,
                                region=theRegion)

        if self.opts.all:
            self.opts.caseSize = True
            self.opts.shortBCreport = True
            self.opts.longBCreport = True
            self.opts.dimensions = True
            self.opts.internal = True
            self.opts.linearSolvers = True
            self.opts.relaxationFactors = True
            self.opts.processorMatrix = True
            self.opts.decomposition = True

        if self.opts.time:
            try:
                self.opts.time = sol.timeName(
                    sol.timeIndex(self.opts.time, minTime=True))
            except IndexError:
                error("The specified time", self.opts.time,
                      "doesn't exist in the case")
            print_("Using time t=" + self.opts.time + "\n")

        needsPolyBoundaries = False
        needsInitialTime = False

        if self.opts.longBCreport:
            needsPolyBoundaries = True
            needsInitialTime = True
        if self.opts.shortBCreport:
            needsPolyBoundaries = True
            needsInitialTime = True
        if self.opts.dimensions:
            needsInitialTime = True
        if self.opts.internal:
            needsInitialTime = True
        if self.opts.decomposition:
            needsPolyBoundaries = True

        defaultProc = None
        if self.opts.parallel:
            defaultProc = 0

        if needsPolyBoundaries:
            proc = None
            boundary = BoundaryDict(
                sol.name,
                region=theRegion,
                time=self.opts.time,
                treatBinaryAsASCII=self.opts.boundaryTreatBinaryAsASCII,
                processor=defaultProc)

            boundMaxLen = 0
            boundaryNames = []
            for b in boundary:
                if b.find("procBoundary") != 0:
                    boundaryNames.append(b)
            if self.opts.patches != None:
                tmp = boundaryNames
                boundaryNames = []
                for b in tmp:
                    for p in self.opts.patches:
                        if fnmatch(b, p):
                            boundaryNames.append(b)
                            break

            if self.opts.expatches != None:
                tmp = boundaryNames
                boundaryNames = []
                for b in tmp:
                    keep = True
                    for p in self.opts.expatches:
                        if fnmatch(b, p):
                            keep = False
                            break
                    if keep:
                        boundaryNames.append(b)

            for b in boundaryNames:
                boundMaxLen = max(boundMaxLen, len(b))
            boundaryNames.sort()

        if self.opts.time == None:
            procTime = "constant"
        else:
            procTime = self.opts.time

        if needsInitialTime:
            fields = {}

            if self.opts.time == None:
                try:
                    time = sol.timeName(0)
                except IndexError:
                    error("There is no timestep in the case")
            else:
                time = self.opts.time

            tDir = sol[time]

            nameMaxLen = 0

            for f in tDir:
                try:
                    fields[f.baseName()] = f.getContent(
                        listLengthUnparsed=self.opts.longlist,
                        treatBinaryAsASCII=self.opts.treatBinaryAsASCII,
                        doMacroExpansion=self.opts.doMacros)
                    nameMaxLen = max(nameMaxLen, len(f.baseName()))
                except PyFoamParserError:
                    e = sys.exc_info()[
                        1]  # Needed because python 2.5 does not support 'as e'
                    warning("Couldn't parse", f.name, "because of an error:",
                            e, " -> skipping")

            fieldNames = list(fields.keys())
            fieldNames.sort()

        if self.opts.caseSize:
            print_(ReST.heading("Size of the case"))

            nFaces = 0
            nPoints = 0
            nCells = 0
            if self.opts.parallel:
                procs = list(range(sol.nrProcs()))
                print_("Accumulated from", sol.nrProcs(), "processors")
            else:
                procs = [None]

            for p in procs:
                info = MeshInformation(sol.name,
                                       processor=p,
                                       region=theRegion,
                                       time=self.opts.time)
                nFaces += info.nrOfFaces()
                nPoints += info.nrOfPoints()
                try:
                    nCells += info.nrOfCells()
                except:
                    nCells = "Not available"
            tab = ReST.table()
            tab[0] = ("Faces", nFaces)
            tab[1] = ("Points", nPoints)
            tab[2] = ("Cells", nCells)
            print_(tab)

        if self.opts.decomposition:
            print_(ReST.heading("Decomposition"))

            if sol.nrProcs() < 2:
                print_("This case is not decomposed")
            else:
                print_("Case is decomposed for", sol.nrProcs(), "processors")
                print_()

                nCells = []
                nFaces = []
                nPoints = []
                for p in sol.processorDirs():
                    info = MeshInformation(sol.name,
                                           processor=p,
                                           region=theRegion,
                                           time=self.opts.time)
                    nPoints.append(info.nrOfPoints())
                    nFaces.append(info.nrOfFaces())
                    nCells.append(info.nrOfCells())

                digits = int(
                    ceil(
                        log10(
                            max(sol.nrProcs(), max(nCells), max(nFaces),
                                max(nPoints))))) + 2
                nameLen = max(len("Points"), boundMaxLen)

                tab = ReST.table()
                tab[0] = ["CPU"] + list(range(sol.nrProcs()))

                tab.addLine()

                tab[1] = ["Points"] + nPoints
                tab[2] = ["Faces"] + nFaces
                tab[3] = ["Cells"] + nCells
                tab.addLine(head=True)

                nr = 3
                for b in boundaryNames:
                    nr += 1
                    tab[(nr, 0)] = b
                    for i, p in enumerate(sol.processorDirs()):
                        try:
                            nFaces = ParsedBoundaryDict(
                                sol.boundaryDict(processor=p,
                                                 region=theRegion,
                                                 time=self.opts.time),
                                treatBinaryAsASCII=self.opts.
                                boundaryTreatBinaryAsASCII)[b]["nFaces"]
                        except IOError:
                            nFaces = ParsedBoundaryDict(
                                sol.boundaryDict(processor=p,
                                                 region=theRegion),
                                treatBinaryAsASCII=self.opts.
                                boundaryTreatBinaryAsASCII)[b]["nFaces"]
                        except KeyError:
                            nFaces = 0

                        tab[(nr, i + 1)] = nFaces

                print_(tab)

        if self.opts.longBCreport:
            print_(ReST.heading("The boundary conditions for t =", time))

            for b in boundaryNames:
                print_(
                    ReST.buildHeading("Boundary: ",
                                      b,
                                      level=self.opts.headingLevel + 1))
                bound = boundary[b]
                print_(":Type:\t", bound["type"])
                if "physicalType" in bound:
                    print_(":Physical:\t", bound["physicalType"])
                print_(":Faces:\t", bound["nFaces"])
                print_()
                heads = ["Field", "type"]
                tab = ReST.table()
                tab[0] = heads
                tab.addLine(head=True)
                for row, fName in enumerate(fieldNames):
                    tab[(row + 1, 0)] = fName
                    f = fields[fName]
                    if "boundaryField" not in f:
                        tab[(row + 1, 1)] = "Not a field file"
                    elif b not in f["boundaryField"]:
                        tab[(row + 1, 1)] = "MISSING !!!"
                    else:
                        bf = f["boundaryField"][b]

                        for k in bf:
                            try:
                                col = heads.index(k)
                            except ValueError:
                                col = len(heads)
                                tab[(0, col)] = k
                                heads.append(k)
                            cont = str(bf[k])
                            if type(bf[k]) == Field:
                                if bf[k].isBinary():
                                    cont = bf[k].binaryString()

                            if cont.find("\n") >= 0:
                                tab[(row + 1,
                                     col)] = cont[:cont.find("\n")] + "..."
                            else:
                                tab[(row + 1, col)] = cont
                print_(tab)

        if self.opts.shortBCreport:
            print_(ReST.heading("Table of boundary conditions for t =", time))

            types = {}
            hasPhysical = False
            for b in boundary:
                if "physicalType" in boundary[b]:
                    hasPhysical = True

                types[b] = {}

                for fName in fields:
                    f = fields[fName]
                    try:
                        if b not in f["boundaryField"]:
                            types[b][fName] = "MISSING"
                        else:
                            types[b][fName] = f["boundaryField"][b]["type"]
                    except KeyError:
                        types[b][fName] = "Not a field"

            tab = ReST.table()
            tab[0] = [""] + boundaryNames
            tab.addLine()
            tab[(1, 0)] = "Patch Type"
            for i, b in enumerate(boundaryNames):
                tab[(1, i + 1)] = boundary[b]["type"]

            nr = 2
            if hasPhysical:
                tab[(nr, 0)] = "Physical Type"
                for i, b in enumerate(boundaryNames):
                    if "physicalType" in boundary[b]:
                        tab[(nr, i + 1)] = boundary[b]["physicalType"]
                nr += 1

            tab[(nr, 0)] = "Length"
            for i, b in enumerate(boundaryNames):
                tab[(nr, i + 1)] = boundary[b]["nFaces"]
            nr += 1
            tab.addLine(head=True)

            for fName in fieldNames:
                tab[(nr, 0)] = fName
                for i, b in enumerate(boundaryNames):
                    tab[(nr, i + 1)] = types[b][fName]
                nr += 1

            print_(tab)

        if self.opts.dimensions:
            print_(ReST.heading("Dimensions of fields for t =", time))

            tab = ReST.table()
            tab[0] = ["Name"] + "[ kg m s K mol A cd ]".split()[1:-1]
            tab.addLine(head=True)
            for i, fName in enumerate(fieldNames):
                f = fields[fName]
                try:
                    dim = str(f["dimensions"]).split()[1:-1]
                except KeyError:
                    dim = ["-"] * 7
                tab[i + 1] = [fName] + dim
            print_(tab)

        if self.opts.internal:
            print_(ReST.heading("Internal value of fields for t =", time))

            tab = ReST.table()
            tab[0] = ["Name", "Value"]
            tab.addLine(head=True)
            for i, fName in enumerate(fieldNames):
                f = fields[fName]

                try:
                    if f["internalField"].isBinary():
                        val = f["internalField"].binaryString()
                    else:
                        cont = str(f["internalField"])
                        if cont.find("\n") >= 0:
                            val = cont[:cont.find("\n")] + "..."
                        else:
                            val = cont
                except KeyError:
                    val = "Not a field file"
                tab[i + 1] = [fName, val]
            print_(tab)

        if self.opts.processorMatrix:
            print_(ReST.heading("Processor matrix"))

            if sol.nrProcs() < 2:
                print_("This case is not decomposed")
            else:
                matrix = [[
                    0,
                ] * sol.nrProcs() for i in range(sol.nrProcs())]

                for i, p in enumerate(sol.processorDirs()):
                    try:
                        bound = ParsedBoundaryDict(
                            sol.boundaryDict(processor=p,
                                             region=theRegion,
                                             time=self.opts.time),
                            treatBinaryAsASCII=self.opts.
                            boundaryTreatBinaryAsASCII)
                    except IOError:
                        bound = ParsedBoundaryDict(
                            sol.boundaryDict(processor=p,
                                             treatBinaryAsASCII=self.opts.
                                             boundaryTreatBinaryAsASCII,
                                             region=theRegion),
                            treatBinaryAsASCII=self.opts.
                            boundaryTreatBinaryAsASCII)

                    for j in range(sol.nrProcs()):
                        name = "procBoundary%dto%d" % (j, i)
                        name2 = "procBoundary%dto%d" % (i, j)
                        if name in bound:
                            matrix[i][j] = bound[name]["nFaces"]
                        if name2 in bound:
                            matrix[i][j] = bound[name2]["nFaces"]

                print_("Matrix of processor interactions (faces)")
                print_()

                tab = ReST.table()
                tab[0] = ["CPU"] + list(range(sol.nrProcs()))
                tab.addLine(head=True)

                for i, col in enumerate(matrix):
                    tab[i + 1] = [i] + matrix[i]

                print_(tab)

        if self.opts.linearSolvers:
            print_(ReST.heading("Linear Solvers"))

            linTable = ReST.table()

            fvSol = ParsedParameterFile(
                path.join(sol.systemDir(), "fvSolution"),
                treatBinaryAsASCII=self.opts.treatBinaryAsASCII)
            allInfo = {}
            for sName in fvSol["solvers"]:
                raw = fvSol["solvers"][sName]
                info = {}
                if type(raw) in [dict, DictProxy]:
                    # fvSolution format in 1.7
                    try:
                        info["solver"] = raw["solver"]
                    except KeyError:
                        info["solver"] = "<none>"
                    solverData = raw
                else:
                    info["solver"] = raw[0]
                    solverData = raw[1]

                if type(solverData) in [dict, DictProxy]:
                    try:
                        info["tolerance"] = solverData["tolerance"]
                    except KeyError:
                        info["tolerance"] = 1.
                    try:
                        info["relTol"] = solverData["relTol"]
                    except KeyError:
                        info["relTol"] = 0.
                else:
                    # the old (pre-1.5) fvSolution-format
                    info["tolerance"] = solverData
                    info["relTol"] = raw[2]

                allInfo[sName] = info

            linTable[0] = ["Name", "Solver", "Abs. Tolerance", "Relative Tol."]
            linTable.addLine(head=True)

            nr = 0
            for n, i in iteritems(allInfo):
                nr += 1
                linTable[nr] = (n, i["solver"], i["tolerance"], i["relTol"])
            print_(linTable)

        if self.opts.relaxationFactors:
            print_(ReST.heading("Relaxation"))

            fvSol = ParsedParameterFile(
                path.join(sol.systemDir(), "fvSolution"),
                treatBinaryAsASCII=self.opts.treatBinaryAsASCII)
            if "relaxationFactors" in fvSol:
                relax = fvSol["relaxationFactors"]
                tab = ReST.table()
                tab[0] = ["Name", "Factor"]
                tab.addLine(head=True)
                nr = 0
                if "fields" in relax or "equations" in relax:
                    # New syntax
                    for k in ["fields", "equations"]:
                        if k in relax:
                            for n, f in iteritems(relax[k]):
                                nr += 1
                                tab[nr] = [k + ": " + n, f]
                else:
                    for n, f in iteritems(relax):
                        nr += 1
                        tab[nr] = [n, f]
                print_(tab)
            else:
                print_("No relaxation factors defined for this case")
    def doRegion(self,theRegion):
        ReST=RestructuredTextHelper(defaultHeading=self.opts.headingLevel)

        if self.opts.allRegions:
            print_(ReST.buildHeading("Region: ",theRegion,level=self.opts.headingLevel-1))

        sol=SolutionDirectory(self.parser.getArgs()[0],
                              archive=None,
                              parallel=self.opts.parallel,
                              paraviewLink=False,
                              region=theRegion)

        if self.opts.all:
            self.opts.caseSize=True
            self.opts.shortBCreport=True
            self.opts.longBCreport=True
            self.opts.dimensions=True
            self.opts.internal=True
            self.opts.linearSolvers=True
            self.opts.relaxationFactors=True
            self.opts.processorMatrix=True
            self.opts.decomposition=True

        if self.opts.time:
            try:
                self.opts.time=sol.timeName(sol.timeIndex(self.opts.time,minTime=True))
            except IndexError:
                error("The specified time",self.opts.time,"doesn't exist in the case")
            print_("Using time t="+self.opts.time+"\n")

        needsPolyBoundaries=False
        needsInitialTime=False

        if self.opts.longBCreport:
            needsPolyBoundaries=True
            needsInitialTime=True
        if self.opts.shortBCreport:
            needsPolyBoundaries=True
            needsInitialTime=True
        if self.opts.dimensions:
            needsInitialTime=True
        if self.opts.internal:
            needsInitialTime=True
        if self.opts.decomposition:
            needsPolyBoundaries=True

        defaultProc=None
        if self.opts.parallel:
            defaultProc=0

        if needsPolyBoundaries:
            proc=None
            boundary=BoundaryDict(sol.name,
                                  region=theRegion,
                                  time=self.opts.time,
                                  treatBinaryAsASCII=self.opts.treatBinaryAsASCII,
                                  processor=defaultProc)

            boundMaxLen=0
            boundaryNames=[]
            for b in boundary:
                if b.find("procBoundary")!=0:
                    boundaryNames.append(b)
            if self.opts.patches!=None:
                tmp=boundaryNames
                boundaryNames=[]
                for b in tmp:
                    for p in self.opts.patches:
                        if fnmatch(b,p):
                            boundaryNames.append(b)
                            break

            if self.opts.expatches!=None:
                tmp=boundaryNames
                boundaryNames=[]
                for b in tmp:
                    keep=True
                    for p in self.opts.expatches:
                        if fnmatch(b,p):
                            keep=False
                            break
                    if keep:
                        boundaryNames.append(b)

            for b in boundaryNames:
                boundMaxLen=max(boundMaxLen,len(b))
            boundaryNames.sort()

        if self.opts.time==None:
            procTime="constant"
        else:
            procTime=self.opts.time

        if needsInitialTime:
            fields={}

            if self.opts.time==None:
                try:
                    time=sol.timeName(0)
                except IndexError:
                    error("There is no timestep in the case")
            else:
                time=self.opts.time

            tDir=sol[time]

            nameMaxLen=0

            for f in tDir:
                try:
                    fields[f.baseName()]=f.getContent(listLengthUnparsed=self.opts.longlist,
                                                      treatBinaryAsASCII=self.opts.treatBinaryAsASCII,
                                                      doMacroExpansion=self.opts.doMacros)
                    nameMaxLen=max(nameMaxLen,len(f.baseName()))
                except PyFoamParserError:
                    e = sys.exc_info()[1] # Needed because python 2.5 does not support 'as e'
                    warning("Couldn't parse",f.name,"because of an error:",e," -> skipping")

            fieldNames=list(fields.keys())
            fieldNames.sort()

        if self.opts.caseSize:
            print_(ReST.heading("Size of the case"))

            nFaces=0
            nPoints=0
            nCells=0
            if self.opts.parallel:
                procs=list(range(sol.nrProcs()))
                print_("Accumulated from",sol.nrProcs(),"processors")
            else:
                procs=[None]

            for p in procs:
                info=MeshInformation(sol.name,
                                     processor=p,
                                     region=theRegion,
                                     time=self.opts.time)
                nFaces+=info.nrOfFaces()
                nPoints+=info.nrOfPoints()
                try:
                    nCells+=info.nrOfCells()
                except:
                    nCells="Not available"
            tab=ReST.table()
            tab[0]=("Faces",nFaces)
            tab[1]=("Points",nPoints)
            tab[2]=("Cells",nCells)
            print_(tab)

        if self.opts.decomposition:
            print_(ReST.heading("Decomposition"))

            if sol.nrProcs()<2:
                print_("This case is not decomposed")
            else:
                print_("Case is decomposed for",sol.nrProcs(),"processors")
                print_()

                nCells=[]
                nFaces=[]
                nPoints=[]
                for p in sol.processorDirs():
                    info=MeshInformation(sol.name,
                                         processor=p,
                                         region=theRegion,
                                         time=self.opts.time)
                    nPoints.append(info.nrOfPoints())
                    nFaces.append(info.nrOfFaces())
                    nCells.append(info.nrOfCells())

                digits=int(ceil(log10(max(sol.nrProcs(),
                                          max(nCells),
                                          max(nFaces),
                                          max(nPoints)
                                          ))))+2
                nameLen=max(len("Points"),boundMaxLen)

                tab=ReST.table()
                tab[0]=["CPU"]+list(range(sol.nrProcs()))

                tab.addLine()

                tab[1]=["Points"]+nPoints
                tab[2]=["Faces"]+nFaces
                tab[3]=["Cells"]+nCells
                tab.addLine(head=True)

                nr=3
                for b in boundaryNames:
                    nr+=1
                    tab[(nr,0)]=b
                    for i,p in enumerate(sol.processorDirs()):
                        try:
                            nFaces= ParsedBoundaryDict(sol.boundaryDict(processor=p,
                                                                        region=theRegion,
                                                                        time=self.opts.time),
                                                       treatBinaryAsASCII=self.opts.treatBinaryAsASCII
                                                       )[b]["nFaces"]
                        except IOError:
                            nFaces= ParsedBoundaryDict(sol.boundaryDict(processor=p,
                                                                        region=theRegion),
                                                       treatBinaryAsASCII=self.opts.treatBinaryAsASCII
                                                       )[b]["nFaces"]
                        except KeyError:
                            nFaces=0

                        tab[(nr,i+1)]=nFaces

                print_(tab)

        if self.opts.longBCreport:
            print_(ReST.heading("The boundary conditions for t =",time))

            for b in boundaryNames:
                print_(ReST.buildHeading("Boundary: ",b,level=self.opts.headingLevel+1))
                bound=boundary[b]
                print_(":Type:\t",bound["type"])
                if "physicalType" in bound:
                    print_(":Physical:\t",bound["physicalType"])
                print_(":Faces:\t",bound["nFaces"])
                print_()
                heads=["Field","type"]
                tab=ReST.table()
                tab[0]=heads
                tab.addLine(head=True)
                for row,fName in enumerate(fieldNames):
                    tab[(row+1,0)]=fName
                    f=fields[fName]
                    if "boundaryField" not in f:
                        tab[(row+1,1)]="Not a field file"
                    elif b not in f["boundaryField"]:
                        tab[(row+1,1)]="MISSING !!!"
                    else:
                        bf=f["boundaryField"][b]

                        for k in bf:
                            try:
                                col=heads.index(k)
                            except ValueError:
                                col=len(heads)
                                tab[(0,col)]=k
                                heads.append(k)
                            cont=str(bf[k])
                            if type(bf[k])==Field:
                                if bf[k].isBinary():
                                    cont= bf[k].binaryString()

                            if cont.find("\n")>=0:
                                tab[(row+1,col)]=cont[:cont.find("\n")]+"..."
                            else:
                                tab[(row+1,col)]=cont
                print_(tab)

        if self.opts.shortBCreport:
            print_(ReST.heading("Table of boundary conditions for t =",time))

            types={}
            hasPhysical=False
            for b in boundary:
                if "physicalType" in boundary[b]:
                    hasPhysical=True

                types[b]={}

                for fName in fields:
                    f=fields[fName]
                    try:
                        if b not in f["boundaryField"]:
                            types[b][fName]="MISSING"
                        else:
                            types[b][fName]=f["boundaryField"][b]["type"]
                    except KeyError:
                        types[b][fName]="Not a field"

            tab=ReST.table()
            tab[0]=[""]+boundaryNames
            tab.addLine()
            tab[(1,0)]="Patch Type"
            for i,b in enumerate(boundaryNames):
                tab[(1,i+1)]=boundary[b]["type"]

            nr=2
            if hasPhysical:
                tab[(nr,0)]="Physical Type"
                for i,b in enumerate(boundaryNames):
                    if "physicalType" in boundary[b]:
                        tab[(nr,i+1)]=boundary[b]["physicalType"]
                nr+=1

            tab[(nr,0)]="Length"
            for i,b in enumerate(boundaryNames):
                tab[(nr,i+1)]=boundary[b]["nFaces"]
            nr+=1
            tab.addLine(head=True)

            for fName in fieldNames:
                tab[(nr,0)]=fName
                for i,b in enumerate(boundaryNames):
                    tab[(nr,i+1)]=types[b][fName]
                nr+=1

            print_(tab)

        if self.opts.dimensions:
            print_(ReST.heading("Dimensions of fields for t =",time))

            tab=ReST.table()
            tab[0]=["Name"]+"[ kg m s K mol A cd ]".split()[1:-1]
            tab.addLine(head=True)
            for i,fName in enumerate(fieldNames):
                f=fields[fName]
                try:
                    dim=str(f["dimensions"]).split()[1:-1]
                except KeyError:
                    dim=["-"]*7
                tab[i+1]=[fName]+dim
            print_(tab)

        if self.opts.internal:
            print_(ReST.heading("Internal value of fields for t =",time))

            tab=ReST.table()
            tab[0]=["Name","Value"]
            tab.addLine(head=True)
            for i,fName in enumerate(fieldNames):
                f=fields[fName]

                try:
                    if f["internalField"].isBinary():
                        val=f["internalField"].binaryString()
                    else:
                        cont=str(f["internalField"])
                        if cont.find("\n")>=0:
                            val=cont[:cont.find("\n")]+"..."
                        else:
                            val=cont
                except KeyError:
                    val="Not a field file"
                tab[i+1]=[fName,val]
            print_(tab)

        if self.opts.processorMatrix:
            print_(ReST.heading("Processor matrix"))

            if sol.nrProcs()<2:
                print_("This case is not decomposed")
            else:
                matrix=[ [0,]*sol.nrProcs() for i in range(sol.nrProcs())]

                for i,p in enumerate(sol.processorDirs()):
                    try:
                        bound=ParsedBoundaryDict(sol.boundaryDict(processor=p,
                                                                  region=theRegion,
                                                                  time=self.opts.time)
                                                 ,treatBinaryAsASCII=self.opts.treatBinaryAsASCII)
                    except IOError:
                        bound=ParsedBoundaryDict(sol.boundaryDict(processor=p,
                                                                  treatBinaryAsASCII=self.opts.treatBinaryAsASCII,
                                                                  region=theRegion)
                                                 ,treatBinaryAsASCII=self.opts.treatBinaryAsASCII)

                    for j in range(sol.nrProcs()):
                        name="procBoundary%dto%d" %(j,i)
                        name2="procBoundary%dto%d" %(i,j)
                        if name in bound:
                            matrix[i][j]=bound[name]["nFaces"]
                        if name2 in bound:
                            matrix[i][j]=bound[name2]["nFaces"]

                print_("Matrix of processor interactions (faces)")
                print_()

                tab=ReST.table()
                tab[0]=["CPU"]+list(range(sol.nrProcs()))
                tab.addLine(head=True)

                for i,col in enumerate(matrix):
                    tab[i+1]=[i]+matrix[i]

                print_(tab)

        if self.opts.linearSolvers:
            print_(ReST.heading("Linear Solvers"))

            linTable=ReST.table()

            fvSol=ParsedParameterFile(path.join(sol.systemDir(),"fvSolution"),
                                      treatBinaryAsASCII=self.opts.treatBinaryAsASCII)
            allInfo={}
            for sName in fvSol["solvers"]:
                raw=fvSol["solvers"][sName]
                info={}
                if type(raw) in [dict,DictProxy]:
                    # fvSolution format in 1.7
                    info["solver"]=raw["solver"]
                    solverData=raw
                else:
                    info["solver"]=raw[0]
                    solverData=raw[1]

                if type(solverData) in [dict,DictProxy]:
                    try:
                        info["tolerance"]=solverData["tolerance"]
                    except KeyError:
                        info["tolerance"]=1.
                    try:
                        info["relTol"]=solverData["relTol"]
                    except KeyError:
                        info["relTol"]=0.
                else:
                    # the old (pre-1.5) fvSolution-format
                    info["tolerance"]=solverData
                    info["relTol"]=raw[2]

                allInfo[sName]=info

            linTable[0]=["Name","Solver","Abs. Tolerance","Relative Tol."]
            linTable.addLine(head=True)

            nr=0
            for n,i in iteritems(allInfo):
                nr+=1
                linTable[nr]=(n,i["solver"],i["tolerance"],i["relTol"])
            print_(linTable)

        if self.opts.relaxationFactors:
            print_(ReST.heading("Relaxation"))

            fvSol=ParsedParameterFile(path.join(sol.systemDir(),"fvSolution"),
                                      treatBinaryAsASCII=self.opts.treatBinaryAsASCII)
            if "relaxationFactors" in fvSol:
                tab=ReST.table()
                tab[0]=["Name","Factor"]
                tab.addLine(head=True)
                nr=0
                for n,f in iteritems(fvSol["relaxationFactors"]):
                    nr+=1
                    tab[nr]=[n,f]
                print_(tab)
            else:
                print_("No relaxation factors defined for this case")