Ejemplo n.º 1
0
    def __init__(self, progress=False):
        """
        :param progress: Print time progress on console?
        """
        self.analyzers = {}
        self.time = ""
        self.oDir = ""
        self.line = LineReader(config().getboolean("SolverOutput",
                                                   "stripSpaces"))
        self.timeListeners = []
        self.timeTriggers = []
        self.resetFileTriggers = []

        self.customExpr = re.compile("Custom([0-9]+)_(.+)")

        if progress:
            self.progressOut = ProgressOutput(stdout)
        else:
            self.progressOut = ProgressOutput()

        # tm=CountLineAnalyzer()
        tm = TimeLineAnalyzer()
        self.addAnalyzer("Time", tm)
        tm.addListener(self.setTime)

        self.analyzedLines = 0
Ejemplo n.º 2
0
    def __init__(self, progress=False):
        """
        @param progress: Print time progress on console?
        """
        self.analyzers = {}
        self.time = ""
        self.oDir = ""
        self.line = LineReader()
        self.timeListeners = []
        self.timeTriggers = []

        self.customExpr = re.compile("Custom([0-9]+)_(.+)")

        self.progressOut = None
        if progress:
            self.progressOut = ProgressOutput(stdout)

        tm = TimeLineAnalyzer(progress=progress)
        self.addAnalyzer("Time", tm)
        tm.addListener(self.setTime)
    def __init__(self,progress=False):
        """
        :param progress: Print time progress on console?
        """
        self.analyzers={}
        self.time=""
        self.oDir=""
        self.line=LineReader(config().getboolean("SolverOutput","stripSpaces"))
        self.timeListeners=[]
        self.timeTriggers=[]

        self.customExpr=re.compile("Custom([0-9]+)_(.+)")

        if progress:
            self.progressOut=ProgressOutput(stdout)
        else:
            self.progressOut=ProgressOutput()

        tm=TimeLineAnalyzer()
        self.addAnalyzer("Time",tm)
        tm.addListener(self.setTime)
Ejemplo n.º 4
0
    def __init__(self,progress=False):
        """
        @param progress: Print time progress on console?
        """
        self.analyzers={}
        self.time=""
        self.oDir=""
        self.line=LineReader()
        self.timeListeners=[]
        self.timeTriggers=[]

        self.progressOut=None
        if progress:
            self.progressOut=ProgressOutput(stdout)
        
        tm=TimeLineAnalyzer(progress=progress)
        self.addAnalyzer("Time",tm)
        tm.addListener(self.setTime)
Ejemplo n.º 5
0
class FoamLogAnalyzer(object):
    """Base class for all analyzers

    Administrates and calls a number of LogLineAnlayzers for each
    line"""
    def __init__(self, progress=False):
        """
        :param progress: Print time progress on console?
        """
        self.analyzers = {}
        self.time = ""
        self.oDir = ""
        self.line = LineReader(config().getboolean("SolverOutput",
                                                   "stripSpaces"))
        self.timeListeners = []
        self.timeTriggers = []
        self.resetFileTriggers = []

        self.customExpr = re.compile("Custom([0-9]+)_(.+)")

        if progress:
            self.progressOut = ProgressOutput(stdout)
        else:
            self.progressOut = ProgressOutput()

        # tm=CountLineAnalyzer()
        tm = TimeLineAnalyzer()
        self.addAnalyzer("Time", tm)
        tm.addListener(self.setTime)

        self.analyzedLines = 0

    def tearDown(self):
        """Remove reference to self in children (hoping to remove
        circular dependencies)"""

        for a in list(self.analyzers.values()):
            a.tearDown()
            a.setParent(None)

    def collectData(self, structured=False):
        """Collect dictionaries of collected data (current state)
        from the analyzers
        :return: the dictionary"""

        result = {}

        for nm in self.analyzers:
            data = self.analyzers[nm].getCurrentData(structured=structured)
            if len(data) > 0:
                m = self.customExpr.match(nm)
                if m:
                    if not "Custom" in result:
                        result["Custom"] = {}
                    nr, name = m.groups()
                    result["Custom"][name] = data

                # this will store custom data twice. But we'll keep it
                # for backward-compatibility
                result[nm] = data

        return result

    def summarizeData(self, col=80):
        """Get a summary of the data"""
        result = "=" * col
        result += "\nt = {:20}\n".format(self.getTime())

        data = self.collectData(structured=True)

        for k, v in iteritems(data):
            if k.find("Custom") == 0 and len(k) > 9 and k[8] == "_":
                kk = k[9:]
            elif k in ["Custom"]:
                continue
            else:
                kk = k

            if isinstance(v, (dict, )):
                result += kk + " " + "-" * (col - len(kk) - 1) + "\n"
                isDicts = True
                for k1, v1 in iteritems(v):
                    if not isinstance(v1, (dict, )):
                        isDicts = False
                        break
                if not isDicts:
                    maxLen = max([len(k1) for k1 in v.keys()])
                    wFormat = "{:%d} : {:8g}" % maxLen
                    chunks = [
                        wFormat.format(k1, v[k1]) for k1 in sorted(v.keys())
                    ]
                    maxLen = max([len(c) for c in chunks])
                    chunks = [
                        c if len(c) >= maxLen else c + " " * (maxLen - len(c))
                        for c in chunks
                    ]
                    nrChunks = col // (max([len(e) for e in chunks]) + 3)
                    for i in range(0, len(chunks), nrChunks):
                        result += " | ".join(chunks[i:(i + nrChunks)]) + "\n"
                else:
                    maxLen = 0

                    for k1, v1 in iteritems(v):
                        maxLen = max(
                            maxLen,
                            max([len(k1) + 2 - 8] +
                                [len(k2) for k2 in v1.keys()]))

                    wFormat = "{:%d} : {:8g}" % maxLen
                    chunks = {}
                    chunkLen = 0
                    for k1, v1 in iteritems(v):
                        chunks[k1] = [
                            wFormat.format(k2, v1[k2])
                            for k2 in sorted(v1.keys())
                        ]
                        chunkLen = max(chunkLen,
                                       max([len(e) for e in chunks[k1]]))

                    for k1 in sorted(v.keys()):
                        chunks[k1] = [
                            k1 + " " + "_" * (chunkLen - len(k1) - 1)
                        ] + chunks[k1]
                        chunks[k1] = [
                            c if len(c) >= chunkLen else c + " " *
                            (chunkLen - len(c)) for c in chunks[k1]
                        ]
                        nrChunks = col // (chunkLen + 3)
                        for i in range(0, len(chunks[k1]), nrChunks):
                            result += " | ".join(
                                chunks[k1][i:(i + nrChunks)]) + "\n"
            else:
                result += kk + ": " + v + " " + "-" * (col - len(k) - len(v) -
                                                       3) + "\n"
        return result

    def setTime(self, time):
        """Sets the time and alert all the LineAnalyzers that the time has changed
        :param time: the new value of the time
        """
        if time != self.time:
            self.progressOut.reset()

            self.time = time
            for listener in self.timeListeners:
                listener.timeChanged()
            for nm in self.analyzers:
                self.analyzers[nm].timeChanged()
            self.checkTriggers()

            data = self.collectData()
            for listener in self.timeListeners:
                try:
                    # make sure everyone gets a separate copy
                    listener.setDataSet(deepcopy(data))
                except AttributeError:
                    # seems that the listener doesn't want the data
                    pass

    def resetFile(self):
        """Propagate a reset to the actual analyzers"""
        for nm in self.analyzers:
            self.analyzers[nm].resetFile()

        for f in self.resetFileTriggers:
            f()

    def writeProgress(self, msg):
        """Write a message to the progress output"""
        self.progressOut(msg)

    def addTimeListener(self, listener):
        """:param listener: An object that is notified when the time changes. Has to
        implement a timeChanged method"""
        if not 'timeChanged' in dir(listener):
            error("Error. Object has no timeChanged-method:" + str(listener))
        else:
            self.timeListeners.append(listener)

    def addResetFileTrigger(self, f):
        self.resetFileTriggers.append(f)

    def listAnalyzers(self):
        """:returns: A list with the names of the Analyzers"""
        return list(self.analyzers.keys())

    def hasAnalyzer(self, name):
        """Is this LogLineAnalyzer name there"""
        return name in self.analyzers

    def getAnalyzer(self, name):
        """Get the LogLineAnalyzer name"""
        if name in self.analyzers:
            return self.analyzers[name]
        else:
            return None

    def addAnalyzer(self, name, obj):
        """Adds an analyzer

        obj - A LogLineAnalyzer
        name - the name of the analyzer"""

        obj.setParent(self)
        self.analyzers[name] = obj

    def analyzeLine(self, line):
        """Calls all the anlyzers for a line"""
        self.analyzedLines += 1

        for nm in self.analyzers:
            self.analyzers[nm].doAnalysis(line)

    def analyze(self, fh):
        """Analyzes a file (one line at a time)

        fh - handle of the file"""
        while (self.line.read(fh)):
            self.analyzeLine(self.line.line)

    def goOn(self):
        """Checks with all the analyzers

        If one analyzer returns False it returns False"""
        result = True

        for nm in self.analyzers:
            #            print nm,self.analyzers[nm].goOn()
            result = result and self.analyzers[nm].goOn()

        return result

    def getTime(self):
        """Gets the current time"""
        return str(self.time)

    def isPastTime(self, check):
        """Are we past a given Time?"""
        if check is None:
            return False
        try:
            t = float(self.getTime())
            return t > check
        except ValueError:
            return False

    def setDirectory(self, d):
        """Sets the output directory for all the analyzers"""
        self.oDir = d
        for nm in self.analyzers:
            self.analyzers[nm].setDirectory(self.oDir)

    def getDirectory(self):
        """Gets the output directory"""
        return self.oDir

    def addTrigger(self, time, func, once=True, until=None):
        """Adds a trigger function that is to be called as soon as
        the simulation time exceeds a certain value
        :param time: the time at which the function should be triggered
        :param func: the trigger function
        :param once: Should this function be called once or at every time-step
        :param until: The time until which the trigger should be called"""

        data = {}
        data["time"] = float(time)
        data["func"] = func
        if until != None:
            data["until"] = float(until)
            once = False
        data["once"] = once

        self.timeTriggers.append(data)

    def checkTriggers(self):
        """Check for and execute the triggered functions"""

        remove = []
        for i in range(len(self.timeTriggers)):
            t = self.timeTriggers[i]
            if t["time"] <= self.time:
                t["func"]()
                if t["once"]:
                    remove.append(i)
                elif "until" in t:
                    if t["until"] <= self.time:
                        remove.append(i)

        remove.reverse()

        for i in remove:
            self.timeTriggers.pop(i)
Ejemplo n.º 6
0
class FoamLogAnalyzer(object):
    """Base class for all analyzers

    Administrates and calls a number of LogLineAnlayzers for each
    line"""

    def __init__(self,progress=False):
        """
        @param progress: Print time progress on console?
        """
        self.analyzers={}
        self.time=""
        self.oDir=""
        self.line=LineReader()
        self.timeListeners=[]
        self.timeTriggers=[]

        self.customExpr=re.compile("Custom([0-9]+)_(.+)")

        self.progressOut=None
        if progress:
            self.progressOut=ProgressOutput(stdout)

        tm=TimeLineAnalyzer(progress=progress)
        self.addAnalyzer("Time",tm)
        tm.addListener(self.setTime)

    def tearDown(self):
        """Remove reference to self in children (hoping to remove
        circular dependencies)"""

        for a in list(self.analyzers.values()):
            a.tearDown()
            a.setParent(None)

    def collectData(self):
        """Collect dictionaries of collected data (current state)
        from the analyzers
        @return: the dictionary"""

        result={}

        for nm in self.analyzers:
            data=self.analyzers[nm].getCurrentData()
            if len(data)>0:
                m=self.customExpr.match(nm)
                if m:
                    if not "Custom" in result:
                        result["Custom"]={}
                    nr,name=m.groups()
                    result["Custom"][name]=data

                # this will store custom data twice. But we'll keep it
                    # for backward-compatibility
                result[nm]=data

        return result

    def setTime(self,time):
        """Sets the time and alert all the LineAnalyzers that the time has changed
        @param time: the new value of the time
        """
        if time!=self.time:
            if self.progressOut:
                self.progressOut.reset()

            self.time=time
            for listener in self.timeListeners:
                listener.timeChanged()
            for nm in self.analyzers:
                self.analyzers[nm].timeChanged()
            self.checkTriggers()

            data=self.collectData()
            for listener in self.timeListeners:
                try:
                    # make sure everyone gets a separate copy
                    listener.setDataSet(deepcopy(data))
                except AttributeError:
                    # seems that the listener doesn't want the data
                    pass

    def writeProgress(self,msg):
        """Write a message to the progress output"""
        if self.progressOut:
            self.progressOut(msg)

    def addTimeListener(self,listener):
        """@param listener: An object that is notified when the time changes. Has to
        implement a timeChanged method"""
        if not 'timeChanged' in dir(listener):
            error("Error. Object has no timeChanged-method:"+str(listener))
        else:
            self.timeListeners.append(listener)

    def listAnalyzers(self):
        """@returns: A list with the names of the Analyzers"""
        return list(self.analyzers.keys())

    def hasAnalyzer(self,name):
        """Is this LogLineAnalyzer name there"""
        return name in self.analyzers

    def getAnalyzer(self,name):
        """Get the LogLineAnalyzer name"""
        if name in self.analyzers:
            return self.analyzers[name]
        else:
            return None

    def addAnalyzer(self,name,obj):
        """Adds an analyzer

        obj - A LogLineAnalyzer
        name - the name of the analyzer"""

        obj.setParent(self)
        self.analyzers[name]=obj

    def analyzeLine(self,line):
        """Calls all the anlyzers for a line"""
        for nm in self.analyzers:
            self.analyzers[nm].doAnalysis(line)

    def analyze(self,fh):
        """Analyzes a file (one line at a time)

        fh - handle of the file"""
        while(self.line.read(fh)):
            self.analyzeLine(self.line.line)

    def goOn(self):
        """Checks with all the analyzers

        If one analyzer returns False it returns False"""
        result=True

        for nm in self.analyzers:
            #            print nm,self.analyzers[nm].goOn()
            result=result and self.analyzers[nm].goOn()

        return result

    def getTime(self):
        """Gets the current time"""
        return str(self.time)

    def setDirectory(self,d):
        """Sets the output directory for all the analyzers"""
        self.oDir=d
        for nm in self.analyzers:
            self.analyzers[nm].setDirectory(self.oDir)

    def getDirectory(self):
        """Gets the output directory"""
        return self.oDir

    def addTrigger(self,time,func,once=True,until=None):
        """Adds a trigger function that is to be called as soon as
        the simulation time exceeds a certain value
        @param time: the time at which the function should be triggered
        @param func: the trigger function
        @param once: Should this function be called once or at every time-step
        @param until: The time until which the trigger should be called"""

        data={}
        data["time"]=float(time)
        data["func"]=func
        if until!=None:
            data["until"]=float(until)
            once=False
        data["once"]=once

        self.timeTriggers.append(data)

    def checkTriggers(self):
        """Check for and execute the triggered functions"""

        remove=[]
        for i in range(len(self.timeTriggers)):
            t=self.timeTriggers[i]
            if t["time"]<=self.time:
                t["func"]()
                if t["once"]:
                    remove.append(i)
                elif "until" in t:
                    if t["until"]<=self.time:
                        remove.append(i)

        remove.reverse()

        for i in remove:
            self.timeTriggers.pop(i)
Ejemplo n.º 7
0
class FoamLogAnalyzer(object):
    """Base class for all analyzers

    Administrates and calls a number of LogLineAnlayzers for each
    line"""
    def __init__(self, progress=False):
        """
        @param progress: Print time progress on console?
        """
        self.analyzers = {}
        self.time = ""
        self.oDir = ""
        self.line = LineReader()
        self.timeListeners = []
        self.timeTriggers = []

        self.customExpr = re.compile("Custom([0-9]+)_(.+)")

        self.progressOut = None
        if progress:
            self.progressOut = ProgressOutput(stdout)

        tm = TimeLineAnalyzer(progress=progress)
        self.addAnalyzer("Time", tm)
        tm.addListener(self.setTime)

    def tearDown(self):
        """Remove reference to self in children (hoping to remove
        circular dependencies)"""

        for a in list(self.analyzers.values()):
            a.tearDown()
            a.setParent(None)

    def collectData(self):
        """Collect dictionaries of collected data (current state)
        from the analyzers
        @return: the dictionary"""

        result = {}

        for nm in self.analyzers:
            data = self.analyzers[nm].getCurrentData()
            if len(data) > 0:
                m = self.customExpr.match(nm)
                if m:
                    if not "Custom" in result:
                        result["Custom"] = {}
                    nr, name = m.groups()
                    result["Custom"][name] = data

                # this will store custom data twice. But we'll keep it
                # for backward-compatibility
                result[nm] = data

        return result

    def setTime(self, time):
        """Sets the time and alert all the LineAnalyzers that the time has changed
        @param time: the new value of the time
        """
        if time != self.time:
            if self.progressOut:
                self.progressOut.reset()

            self.time = time
            for listener in self.timeListeners:
                listener.timeChanged()
            for nm in self.analyzers:
                self.analyzers[nm].timeChanged()
            self.checkTriggers()

            data = self.collectData()
            for listener in self.timeListeners:
                try:
                    # make sure everyone gets a separate copy
                    listener.setDataSet(deepcopy(data))
                except AttributeError:
                    # seems that the listener doesn't want the data
                    pass

    def writeProgress(self, msg):
        """Write a message to the progress output"""
        if self.progressOut:
            self.progressOut(msg)

    def addTimeListener(self, listener):
        """@param listener: An object that is notified when the time changes. Has to
        implement a timeChanged method"""
        if not 'timeChanged' in dir(listener):
            error("Error. Object has no timeChanged-method:" + str(listener))
        else:
            self.timeListeners.append(listener)

    def listAnalyzers(self):
        """@returns: A list with the names of the Analyzers"""
        return list(self.analyzers.keys())

    def hasAnalyzer(self, name):
        """Is this LogLineAnalyzer name there"""
        return name in self.analyzers

    def getAnalyzer(self, name):
        """Get the LogLineAnalyzer name"""
        if name in self.analyzers:
            return self.analyzers[name]
        else:
            return None

    def addAnalyzer(self, name, obj):
        """Adds an analyzer

        obj - A LogLineAnalyzer
        name - the name of the analyzer"""

        obj.setParent(self)
        self.analyzers[name] = obj

    def analyzeLine(self, line):
        """Calls all the anlyzers for a line"""
        for nm in self.analyzers:
            self.analyzers[nm].doAnalysis(line)

    def analyze(self, fh):
        """Analyzes a file (one line at a time)

        fh - handle of the file"""
        while (self.line.read(fh)):
            self.analyzeLine(self.line.line)

    def goOn(self):
        """Checks with all the analyzers

        If one analyzer returns False it returns False"""
        result = True

        for nm in self.analyzers:
            #            print nm,self.analyzers[nm].goOn()
            result = result and self.analyzers[nm].goOn()

        return result

    def getTime(self):
        """Gets the current time"""
        return str(self.time)

    def setDirectory(self, d):
        """Sets the output directory for all the analyzers"""
        self.oDir = d
        for nm in self.analyzers:
            self.analyzers[nm].setDirectory(self.oDir)

    def getDirectory(self):
        """Gets the output directory"""
        return self.oDir

    def addTrigger(self, time, func, once=True, until=None):
        """Adds a trigger function that is to be called as soon as
        the simulation time exceeds a certain value
        @param time: the time at which the function should be triggered
        @param func: the trigger function
        @param once: Should this function be called once or at every time-step
        @param until: The time until which the trigger should be called"""

        data = {}
        data["time"] = float(time)
        data["func"] = func
        if until != None:
            data["until"] = float(until)
            once = False
        data["once"] = once

        self.timeTriggers.append(data)

    def checkTriggers(self):
        """Check for and execute the triggered functions"""

        remove = []
        for i in range(len(self.timeTriggers)):
            t = self.timeTriggers[i]
            if t["time"] <= self.time:
                t["func"]()
                if t["once"]:
                    remove.append(i)
                elif "until" in t:
                    if t["until"] <= self.time:
                        remove.append(i)

        remove.reverse()

        for i in remove:
            self.timeTriggers.pop(i)