Example #1
0
def TestChemostatSimple():
    print "=== BEGIN: TestChemostatSimple ==="

    # Settings
    simulate = True  #True - run simulation; False - plot an old results

    # Initialize simulation parameters
    solverParams = AttributeDict({'tFinal': 10., 'tPrint': 0.1})

    # Initialize model parameters
    modelParams = AttributeDict({
        'updateProgress':
        lambda x, y: x,  #:TRICKY: not used,
        'm':
        3.0,
        'K':
        3.7,
        'S_in':
        2.2,
        'X_in':
        0.0,
        'gamma':
        0.6,
        'D_vals':
        np.array([[100, 1], [200, 0.5], [1e6, 1.1]]),
        'S0':
        0.0,
        'X0':
        0.5
    })

    # Create the model
    chemostat = ChemostatSimple(modelParams, initDataStorage=simulate)

    # Run simulation or load old results
    if (simulate == True):
        chemostat.prepareSimulation()
        chemostat.run(solverParams)
    else:
        chemostat.loadResult(simIndex=1)

    # Export to csv file
    chemostat.resultStorage.exportToCsv(fileName=csvFileName)

    # Plot results
    chemostat.plotHDFResults()

    print "=== END: TestChemostatSimple ==="
Example #2
0
    def __init__(self, params=None, **kwargs):
        if params == None:
            params = AttributeDict(kwargs)

        self.fluid = params.fluid
        self.fState = CP.FluidState(self.fluid)
        self.port1 = DMS.FluidPort('C', self.fState)
Example #3
0
    def __init__(self, params=None, **kwargs):
        if params == None:
            params = AttributeDict(kwargs)

        self.condModel = params.condModel
        self.port1 = DMS.ThermalPort('R')
        self.port2 = DMS.ThermalPort('R')
Example #4
0
    def create(self, heatExch=None, **kwargs):
        if heatExch == None:
            heatExch = AttributeDict(kwargs)

        #===== Create the gmsh script =====#
        # Geometry object IDs
        self.pointId = 1
        self.circleArcId = 1
        self.circleId = 1  #loop line
        self.planeSurfaceId = 1

        # Initialize gmsh script
        self.sMesh = StringIO()

        # Add the outer block circle
        self.addCircle2D(radius=heatExch.blockGeom.diameter / 2.0,
                         cellSize=heatExch.externalChannelGeom.cellSize,
                         radialPosition=0,
                         angularPosition=0,
                         name="OuterBoundary")

        # Add the Primary channels
        self.addChannelGroup(heatExch.primaryChannelsGeom)
        self.addChannelGroup(heatExch.secondaryChannelsGeom)

        # Add the cross section surface
        self.addSurface(beginId=1, endId=self.circleId, name="CrossSection")

        # Get the gmsh script
        gmshScript = self.sMesh.getvalue()
        self.sMesh.close()
        #===== Generate the mesh =====#
        self.mesh = FP.Gmsh2D(gmshScript)
Example #5
0
    def __init__(self, params=None, **kwargs):
        if params == None:
            params = AttributeDict(kwargs)

        self.hConv = params.hConv  #convectin coefficient
        self.A = params.A  #convection area

        self.fluidPort = DMS.FluidPort('R')
        self.wallPort = DMS.ThermalPort('R')
Example #6
0
    def __init__(self, params=None, **kwargs):
        if params == None:
            params = AttributeDict(kwargs)

        self.fluid = params.fluid
        self.fState = CP.FluidState(self.fluid)
        self.TOutModel = lambda obj: params.TOut
        self.mDot = params.mDot
        self.flow = DMS.FluidFlow(mDot=self.mDot)
        self.port1 = DMS.FluidPort('R', self.flow)
Example #7
0
    def run(self, params=None, **kwargs):
        if params == None:
            params = AttributeDict(kwargs)

        # Remember the final time
        self.tFinal = params.tFinal

        # Run simulation
        self.simSolver.simulate(tfinal=params.tFinal,
                                ncp=np.floor(params.tFinal / params.tPrint))
        self.resultStorage.finalizeResult()
Example #8
0
	def __init__(self, params = None, **kwargs):
		if params == None:
			params = AttributeDict(kwargs)
			
		self.V = params.V
		if (isinstance(params.fluid, CP.Fluid)):
			self.fluid = params.fluid
		else:
			self.fluid = CP.Fluid(params.fluid)
			
		self.fState = CP.FluidState(self.fluid)
		self.fluidPort = DMS.DynamicCPort(DMS.FluidPort, state = self.fState)
Example #9
0
    def run(self, params=None, **kwargs):
        if params == None:
            params = AttributeDict(kwargs)
        self.solverParams = params

        # Set the simulation parameters
        self.dde.set_sim_params(tfinal=self.solverParams.tFinal,
                                AbsTol=params.absTol,
                                RelTol=params.relTol,
                                dtmax=None)

        # Run the simulator
        self.dde.run()
Example #10
0
    def __init__(self, params=None, **kwargs):
        super(ChemostatSimple, self).__init__(**kwargs)
        if params == None:
            params = AttributeDict(kwargs)

        # Initialize update progress function
        self.updateProgress = params.updateProgress

        # Initialize parameters
        self.m = params.m
        self.K = params.K
        self.S_in = params.S_in
        self.X_in = params.X_in
        self.gamma = params.gamma
        self.D_vals = params.D_vals

        # Create state vector and derivative vector
        stateVarNames = ['S', 'X']
        self.y = NamedStateVector(stateVarNames)
        self.yRes = NamedStateVector(stateVarNames)
        self.yDot = NamedStateVector(stateVarNames)

        # Initialize data storage
        self.resultStorage = ResultStorage(filePath=dataStorageFilePath,
                                           datasetPath=dataStorageDatasetPath)
        if (kwargs.get('initDataStorage', True)):
            self.resultStorage.initializeWriting(varList=['t'] +
                                                 stateVarNames + ['D'],
                                                 chunkSize=1e4)

        # Register time event (changed of D)
        D_val = self.D_vals[0]
        self.D = D_val[1]

        tChangedD = D_val[0]
        for i in range(len(self.D_vals) - 1):
            self.D_val = self.D_vals[i + 1]
            self.timeEventRegistry.add(
                ChemostatSimpleTimeEvent(t=tChangedD,
                                         newValue_D=self.D_val[1]))
            tChangedD += self.D_val[0]

        # Set initial values of the states
        self.y.S = params.S0
        self.y.X = params.X0

        # Set all the initial state values
        self.y0 = self.y.get(copy=True)

        # Set the initial flags
        self.sw0 = [True]
Example #11
0
    def setState(self, params=None, **kwargs):
        if params == None:
            params = AttributeDict(kwargs)

        self.sourceType = params.sourceType
        if (self.sourceType == self.TP):
            self.T = params.T
            self.p = params.p
        elif (self.sourceType == self.PQ):
            self.p = params.p
            self.q = params.q
        elif (self.sourceType == self.TQ):
            self.T = params.T
            self.q = params.q
Example #12
0
    def __init__(self, params=None, **kwargs):
        if params == None:
            params = AttributeDict(kwargs)

        self.fluid = params.fluid  #fluid
        self.etaS = params.etaS  #isentropic efficiency
        self.fQ = params.fQ  #fraction of heat loss to ambient
        self.V = params.V  #displacement volume

        self.n = 0.0  #number of revolutions per second
        self.fStateOut = CP.FluidState(self.fluid)

        self.flow = DMS.FluidFlow()
        self.portOut = DMS.FluidPort('R', self.flow)
        self.portIn = DMS.FluidPort('R', -self.flow)
Example #13
0
    def addChannelGroup(self, channelGroup=None, **kwargs):
        if channelGroup == None:
            channelGroup = AttributeDict(kwargs)

        if (channelGroup.number <= 0):
            return

        offsetAngle = 2 * np.pi / channelGroup.number
        for i in range(int(channelGroup.number)):
            self.addCircle2D(
                radius=channelGroup.externalDiameter / 2.,
                cellSize=channelGroup.cellSize,
                radialPosition=channelGroup.radialPosition,
                angularPosition=channelGroup.startingAngle + i * offsetAngle,
                name="{0}_{1}".format(channelGroup.channelName, i + 1),
            )
Example #14
0
    def __init__(self, params=None, **kwargs):
        if params == None:
            params = AttributeDict(kwargs)

        self.fluid = params.fluid

        self.fStateIn = CP.FluidState(self.fluid)
        self.fStateOut = CP.FluidState(self.fluid)
        self.fStateDown = CP.FluidState(self.fluid)
        self.fStateTmp = CP.FluidState(self.fluid)

        self.flowOut = DMS.FluidFlow()
        self.heatOut = DMS.HeatFlow()
        self.portIn = DMS.FluidPort('C', self.fStateDown)
        self.portOut = DMS.FluidPort('R', self.flowOut)
        self.thermalPort = DMS.ThermalPort('R', self.heatOut)
Example #15
0
def TestChemostatDDE():
    print "=== BEGIN: TestChemostatDDE ==="

    # Initialize simulation parameters
    solverParams = AttributeDict({
        'tFinal': 500.,
        'tPrint': 0.1,
        'absTol': 1e-16,
        'relTol': 1e-16,
    })

    # Initialize model parameters
    class ModelParams(
    ):  #:TRICKY: here it is also possible to use AttributeDict instead of class ModelParams
        k1 = 10.53
        k2 = 28.6
        k3 = 1074.
        s1_in = 7.5
        s2_in = 75.
        a = 0.5
        m1 = 1.2
        m2 = 0.74
        k_s1 = 7.1
        k_s2 = 9.28
        k_I = 16.
        D = 0.1
        tau1 = 2
        tau2 = 7
        s1_hist_vals = 2.
        x1_hist_vals = 0.1
        s2_hist_vals = 10.
        x2_hist_vals = 0.05

    modelParams = ModelParams()

    chemostat = ChemostatDDE2(modelParams)
    chemostat.run(solverParams)
    chemostat.plotResults()
    #chemostat.plotX1X2()
    #chemostat.plotS1S2()
    #chemostat.plotS1X1()
    #chemostat.plotS2X2()

    print "=== END: TestChemostatDDE ==="
Example #16
0
    def __init__(self, params=None, **kwargs):
        """
        #params.reactions = [reactionEquation, rateConstants]
        #params.species = [speciesVariable, initialValue]
        """
        super(BiochemicalReactions, self).__init__(**kwargs)
        if params == None:
            params = AttributeDict(kwargs)

        # Initialize update progress function
        self.updateProgress = params.updateProgress

        # Get the species variables Xs = [X1, X2, ..., Xn] and their initial values
        self.Xs = np.empty(len(params.species), dtype=(np.str_, 256))
        self.X0s = np.zeros(len(params.species))
        for i, itSpecies in enumerate(params.species):
            self.Xs[i] = itSpecies[0]
            self.X0s[i] = itSpecies[1]

        # Get the reactions = [[left Xs, right Xs, k, ss, rs, f], ...], where:
        # left Xs - the species variables of reactants (i.e. the species variables of the left parts of the reactions)
        # rigth Xs - the species variables of products (i.e. the species variables of the right parts of the reactions)
        # k - the rate constant of the reaction
        # ss - the stoichiometric coefficients of reactants  (e.g. [0,1,1,0,...,1])
        # rs - the stoichiometric coefficients of products (e.g. [1,0,...,0])
        # f - the fluxs (e.g. k*X2*X3*...*Xn)
        self.reactions = self.readReactions(params.reactions, self.Xs)
        #for reaction in self.reactions: print reaction

        # Create a vector with state variable names
        stateVarNames = list(self.Xs)

        # Initialize data storage
        self.resultStorage = ResultStorage(filePath=dataStorageFilePath,
                                           datasetPath=dataStorageDatasetPath)
        if (kwargs.get('initDataStorage', True)):
            self.resultStorage.initializeWriting(varList=['t'] + stateVarNames,
                                                 chunkSize=1e4)

        # Set the initial state values
        self.y0 = self.X0s

        # Set the initial flags
        self.sw0 = [True]
Example #17
0
    def __init__(self, params=None, **kwargs):
        if params == None:
            params = AttributeDict(kwargs)

        self.state = params.initialState
        self.pTankInit = params.pTankInit
        self.inputs = self.Inputs()
        self.outputs = self.Outputs()
        self.parameters = self.Parameters(params)

        # :TRICKY: change the initial state of the controler
        if (self.pTankInit >= self.parameters.pMax
                and self.state == self.FUELING):
            self.state = self.EXTRACTION

        if (self.pTankInit <= self.parameters.pMin
                and self.state == self.EXTRACTION):
            self.state = self.FUELING

        self.executeEntryActions()
Example #18
0
    def run(self, params=None, **kwargs):
        if params == None:
            params = AttributeDict(kwargs)
        self.solverParams = params

        # Initialize results
        self.initResults()

        # Run the main simulation
        mainSimStepIndex = -1
        mainSimTimeRange = np.arange(0, self.solverParams.tFinal,
                                     self.solverParams.mainSimStep)
        for tMainSim in mainSimTimeRange:
            mainSimStepIndex += 1

            # Run the current secondary simulation
            self.runSecSim(tMainSim)

            # Write secondary simulation results
            self.writeResultsSecSim(mainSimStepIndex)
Example #19
0
    def prepareSimulation(self, params=None):
        if params == None:
            params = AttributeDict({
                'absTol': 1e-6,
                'relTol': 1e-6,
            })

        #Define an explicit solver
        simSolver = CVode(self)
        #Create a CVode solver
        #Sets the parameters
        #simSolver.verbosity = LOUD
        simSolver.report_continuously = True
        simSolver.iter = 'Newton'  #Default 'FixedPoint'
        simSolver.discr = 'BDF'  #Default 'Adams'
        #simSolver.discr = 'Adams'
        simSolver.atol = [params.absTol]  #Default 1e-6
        simSolver.rtol = params.relTol  #Default 1e-6
        simSolver.problem_info['step_events'] = True  # activates step events
        #simSolver.maxh = 1.0
        simSolver.store_event_points = True
        self.simSolver = simSolver
Example #20
0
    def __init__(self, params=None, **kwargs):
        if params == None:
            params = AttributeDict(kwargs)
        self.params = params

        # Define the specific growth rates (in 'C' source code)
        self.support_c_code = """
        double mu1(double s, double m, double k) {
            return (m*s)/(k + s);
        }
        
        double mu2(double s, double m, double k, double k_I) {
            return (m*s)/(k + s + (s/k_I)*(s/k_I));
        }
        """

        # Define the equations
        self.eqns = {
            's1':
            'D*(s1_in - s1) - k1*mu1(s1, m1, k_s1)*x1',
            'x1':
            'exp(-a*D*tau1)*mu1(s1(t-tau1), m1, k_s1)*x1(t-tau1) - a*D*x1',
            's2':
            'D*(s2_in - s2) + k2*mu1(s1, m1, k_s1)*x1 - k3*mu2(s2, m2, k_s2, k_I)*x2',
            'x2':
            'exp(-a*D*tau2)*mu2(s2(t-tau2), m2, k_s2, k_I)*x2(t-tau2) - a*D*x2'
        }

        # Initialize tauMax
        self.tauMax = np.max([
            self.params.tau1, self.params.tau2
        ]) + 1  #:TRICKY: give the solver more historical data

        # Compute equilibrium point
        self.equilibriumPoint = self.computeEquilibriumPoint()
        if plotEqulibriumValuesAtTheEnd:
            print "equilibrium point (s1, x1, s2, x2) = ", self.equilibriumPoint
Example #21
0
def TestChemostatDDE():
    print "=== BEGIN: TestChemostatDDE ==="

    # Initialize simulation parameters
    solverParams = AttributeDict({
        'tFinal': 5000.0,
        'tPrint': 0.1,
        'absTol': 1e-16,
        'relTol': 1e-16,
        'mainSimStep': 10.
    })

    # Initialize model parameters
    class ModelParams(
    ):  #:TRICKY: here it is also possible to use AttributeDict instead of class ModelParams
        k1 = 10.53
        k2 = 28.6
        k3 = 1074.
        k4 = 100.
        s1_in = 7.5
        s2_in = 75.
        a = 0.5
        m1 = 1.2
        m2 = 0.74
        k_s1 = 7.1
        k_s2 = 9.28
        k_I = 16.
        D = 0.1
        tau1 = 2
        tau2 = 7
        s1_hist_vals = 2.
        x1_hist_vals = 0.1
        s2_hist_vals = 10.
        x2_hist_vals = 0.05

        DsQs_DMin = 0.0
        DsQs_DMax = 1.0
        DsQs_Step = 0.01

        ESA_DMin = 0.22
        ESA_DMax = 0.33

        ESA_eps = 0.001
        ESA_h = 0.025
        ESA_eps_z = 0.01

    modelParams = ModelParams()
    chemostat = ChemostatDDE2_ESA(modelParams)

    runESA = 0
    if runESA:  #run extremum seeking algorithm
        chemostat.runESA(solverParams)
        resESA = chemostat.getResultsESA()
        if resESA['QMaxIsFound']:
            print "QMax is found: (DMax, QMax) = (", resESA[
                'DMax'], ",", resESA['QMax'], ")."
        else:
            print "QMax is not found."
        chemostat.plotAllResults()
        chemostat.plotDsQs()
    else:  #run simulation
        #chemostat.run(solverParams)
        #chemostat.plotAllResults()
        #chemostat.plotResults()
        #chemostat.plotX1X2()
        #chemostat.plotS1S2()
        #chemostat.plotS1X1()
        #chemostat.plotS2X2()
        chemostat.plotDsQs()

    print "=== END: TestChemostatDDE ==="
Example #22
0
    def create(params=None, **kwargs):
        if params == None:
            params = AttributeDict(kwargs)

        if params.cooler.workingState == 0:
            params.cooler.epsilon = 0.

        tankModel = TankModel(
            updateProgress=params.updateProgress,
            initDataStorage=True,
            controller=TankController(
                initialState=params.controller.initialState,
                pTankInit=params.tank.pInit,
                tWaitBeforeExtraction=params.controller.tWaitBeforeExtraction,
                tWaitBeforeFueling=params.controller.tWaitBeforeFueling,
                pMin=params.controller.pMin,
                pMax=params.controller.pMax,
                mDotExtr=params.controller.mDotExtr,
                hConvTankWaiting=params.tank.hConvInternalWaiting,
                hConvTankExtraction=params.tank.hConvInternalExtraction,
                hConvTankFueling=params.tank.hConvInternalFueling,
                nCompressor=params.controller.nCompressor,
            ),
            fuelingSource=AttributeDict(
                fluid=params.fluid,
                sourceType=params.fuelingSource.sourceType,
                T=params.fuelingSource.T,
                p=params.fuelingSource.p,
                q=params.fuelingSource.q,
            ),
            compressor=AttributeDict(
                fluid=params.fluid,
                etaS=params.compressor.etaS,
                fQ=params.compressor.fQ,
                V=params.compressor.V,
            ),
            cooler=AttributeDict(
                fluid=params.fluid,
                epsilon=params.cooler.epsilon,
            ),
            coolerTemperatureSource=AttributeDict(T=params.cooler.TCooler, ),
            tank=AttributeDict(
                fluid=params.fluid,
                V=params.tank.volume,
                TInit=params.tank.TInit,
                pInit=params.tank.pInit,
            ),
            tankInternalConvection=AttributeDict(
                A=params.tank.wallArea,
                hConv=100.,  #TRICKY: unused parameter
            ),
            liner=AttributeDict(
                material=params.tank.linerMaterial,
                thickness=params.tank.linerThickness,
                conductionArea=params.tank.wallArea,
                port1Type='C',
                port2Type='C',
                numMassSegments=2,
                TInit=params.tank.TInit,
            ),
            composite=AttributeDict(material=params.tank.compositeMaterial,
                                    thickness=params.tank.compositeThickness,
                                    conductionArea=params.tank.wallArea,
                                    port1Type='R',
                                    port2Type='C',
                                    numMassSegments=4,
                                    TInit=params.tank.TInit),
            tankExternalConvection=AttributeDict(
                A=params.tank.wallArea,
                hConv=params.tank.hConvExternal,
            ),
            ambientSource=AttributeDict(
                fluid=params.ambientFluid,
                sourceType=DM.FluidStateSource.TP,
                T=params.TAmbient,
                p=1.e5,
            ),
            extractionSink=AttributeDict(
                fluid=params.fluid,
                mDot=0.0,  #TRICKY: unused parameter
                TOut=params.TAmbient,  #TRICKY: unused parameter
            ),
        )
        return tankModel
Example #23
0
    def __init__(self, params=None, **kwargs):
        super(TankModel, self).__init__(**kwargs)
        if params == None:
            params = AttributeDict(kwargs)

        # Initialize update progress function
        self.updateProgress = params.updateProgress

        # Create state vector and derivative vector
        stateVarNames = [
            'WRealCompressor', 'TTank', 'rhoTank', 'TLiner_1', 'TLiner_2',
            'TComp_1', 'TComp_2', 'TComp_3', 'TComp_4'
        ]
        self.y = NamedStateVector(stateVarNames)
        self.yRes = NamedStateVector(stateVarNames)
        self.yDot = NamedStateVector(stateVarNames)

        # Initialize storage
        self.resultStorage = DMC.ResultStorage(
            filePath=dataStorageFilePath, datasetPath=dataStorageDatasetPath)
        if (kwargs.get('initDataStorage', True)):
            self.resultStorage.initializeWriting(
                varList=['t'] + stateVarNames + [
                    'pTank', 'mTank', 'TCompressorOut', 'TCoolerOut',
                    'QDotCooler', 'QDotComp', 'mDotFueling'
                ],
                chunkSize=10000)

        # Fueling source
        self.fuelingSource = DM.FluidStateSource(params.fuelingSource)
        self.fuelingSource.initState(params.fuelingSource)

        # Compressor
        self.compressor = DM.Compressor(params.compressor)
        # Connect the compressor to the fluid source
        self.compressor.portIn.connect(self.fuelingSource.port1)

        # Cooler
        self.cooler = DM.FluidHeater(params.cooler)
        self.cooler.setEffectivnessModel(epsilon=params.cooler.epsilon)
        # Connect the cooler to the compressor
        self.cooler.portIn.connect(self.compressor.portOut)
        # Connect the cooler to the heater (i.e. temperature source)
        self.coolerTemperatureSource = DMS.ThermalPort(
            'C', DMS.ThermalState(T=params.coolerTemperatureSource.T))
        self.cooler.thermalPort.connect(self.coolerTemperatureSource)

        # Tank chamber
        self.tank = DM.FluidChamber(params.tank)
        self.tank.initialize(params.tank.TInit, params.tank.pInit)
        # Connect the tank to the cooler
        self.tank.fluidPort.connect(self.cooler.portOut)

        # Extraction sink
        self.extractionSink = DM.FlowSource(params.extractionSink)
        # Connect the extraction sink with the tank
        self.extractionSink.port1.connect(self.tank.fluidPort)

        # Tank convection component
        self.tankInternalConvection = DM.ConvectionHeatTransfer(
            params.tankInternalConvection)
        # Connect to the fluid in the tank
        self.tankInternalConvection.fluidPort.connect(self.tank.fluidPort)

        # Tank (Liner)
        self.liner = DM.SolidConductiveBody(params.liner)
        # Connect to the tank convection component
        self.tankInternalConvection.wallPort.connect(self.liner.port1)

        # Tank (composite)
        self.composite = DM.SolidConductiveBody(params.composite)
        # Connect the liner to the composite
        self.composite.port1.connect(self.liner.port2)

        # Ambient fluid component
        self.ambientSource = DM.FluidStateSource(params.ambientSource)
        self.ambientSource.initState(params.ambientSource)

        # Composite convection component
        self.tankExternalConvection = DM.ConvectionHeatTransfer(
            params.tankExternalConvection)
        # Connect the composite convection to the ambient fluid
        self.tankExternalConvection.fluidPort.connect(self.ambientSource.port1)
        # Connect the composite convection to the composite
        self.tankExternalConvection.wallPort.connect(self.composite.port2)

        # Controller
        self.controller = params.controller

        # Initialize the state variables
        self.y.WRealCompressor = 0.  # [W]
        self.y.TLiner_1 = self.liner.T[0]
        self.y.TLiner_2 = self.liner.T[1]
        self.y.TComp_1 = self.composite.T[0]
        self.y.TComp_2 = self.composite.T[1]
        self.y.TComp_3 = self.composite.T[2]
        self.y.TComp_4 = self.composite.T[3]
        self.y.TTank = self.tank.fState.T
        self.y.rhoTank = self.tank.fState.rho

        # Set all the initial state values
        self.y0 = self.y.get(copy=True)

        # Set the initial flags
        self.sw0 = [True]
Example #24
0
def testTankModel():
    print "=== BEGIN: testTankModel ==="
    # Settings
    simulate = True  #True - run simulation; False - plot an old results

    # Create the model
    tankModel = TankModelFactory.create(
        updateProgress=lambda x, y: x,  #:TRICKY: not used
        fluid=CP.Fluid('ParaHydrogen'),
        ambientFluid=CP.Fluid('Air'),
        TAmbient=288.15,
        controller=AttributeDict(
            #initialState = TC.FUELING,
            initialState=TC.EXTRACTION,
            tWaitBeforeExtraction=150.,
            tWaitBeforeFueling=150.,
            pMin=20e5,
            pMax=300e5,
            mDotExtr=30 / 3600.,
            nCompressor=0.53 * 1.44,
        ),
        fuelingSource=AttributeDict(
            sourceType=DM.FluidStateSource.PQ,
            T=15,  #:TRICKY: unused
            p=2.7e5,
            q=0.,
        ),
        compressor=AttributeDict(
            etaS=0.9,
            fQ=0.,
            V=0.5e-3,
        ),
        cooler=AttributeDict(
            workingState=1.,
            epsilon=1.0,
            TCooler=200,
        ),
        tank=AttributeDict(
            wallArea=1.8,
            volume=0.1,
            TInit=300.,
            pInit=20e5,
            linerMaterial='Aluminium6061',
            linerThickness=0.004,
            compositeMaterial='CarbonFiberComposite',
            compositeThickness=0.0105,
            hConvExternal=100.,
            hConvInternalWaiting=10.,
            hConvInternalExtraction=20.,
            hConvInternalFueling=100.,
        ),
    )

    # Run simulation or load old results
    if (simulate):
        tankModel.prepareSimulation()
        tankModel.run(tFinal=2000., tPrint=1.0)
    else:
        tankModel.loadResult(simIndex=1)

    # Export to csv file
    #tankModel.resultStorage.exportToCsv(fileName = csvFileName)

    # Plot results
    tankModel.plotHDFResults()

    print "=== END: testTankModel ==="
Example #25
0
    def runESA(self, solverParams=None, **kwargs):
        if solverParams == None:
            solverParams = AttributeDict(kwargs)
        self.solverParams = solverParams

        # Define helpful function
        def printStep(tMainSim, nextStep, D):
            print "\nAt time ", tMainSim, " do ", nextStep, " with D = ", D
            return

        # Initialize results
        self.initResults()

        # Initialize ESA variables
        QMaxIsFound = False

        eps = self.params.ESA_eps
        eps_z = self.params.ESA_eps_z
        h = self.params.ESA_h
        sigma = 1.0

        # Stage I
        D0 = None
        Q0 = None

        D1 = None
        Q1 = None

        D2 = None
        Q2 = None

        D_minus = None
        D_plus = None

        # Stage II
        lmbd = (np.sqrt(5) - 1) / 2.

        dlt1 = None
        dlt2 = None
        dlt3 = None

        D0_minus = None
        D0_plus = None

        D1_minus = None
        D1_plus = None

        D_p0 = None
        Q_p0 = None

        D_q0 = None
        Q_q0 = None

        D_p1 = None
        Q_p1 = None

        D_q1 = None
        Q_q1 = None

        # Do Step I.0 of ESA
        self.params.D = (self.params.ESA_DMax + self.params.ESA_DMin) / 2.
        nextStep = 'Step I.0'

        # Run the main simulation
        D_prevStep = None
        mainSimStepIndex = -1
        mainSimTimeRange = np.arange(0, self.solverParams.tFinal,
                                     self.solverParams.mainSimStep)
        for tMainSim in mainSimTimeRange:
            mainSimStepIndex += 1

            # Run the secondary simulation
            self.runSecSim(tMainSim)

            # Write secondary simulation results and compute Qs
            self.writeResultsSecSim(mainSimStepIndex)

            # Check for stabilization of the system
            if (QMaxIsFound):
                continue

            # Compute equilibrium and current point
            if (D_prevStep is None) or (D_prevStep != self.params.D):
                D_prevStep = self.params.D
                eqPnt = self.computeEquilibriumPoint()
                #[_s1_eqPnt, _x1_eqPnt, s2_eqPnt, x2_eqPnt] = eqPnt
                #Q_eqPnt = self.computeQ(s2_eqPnt, x2_eqPnt)

            currPnt = self.currPnt
            [_s1_currPnt, _x1_currPnt, s2_currPnt, x2_currPnt] = currPnt
            Q_currPnt = self.computeQ(s2_currPnt, x2_currPnt)

            # Check for the equilibrium point
            if (
                    self.distance(eqPnt, currPnt) > eps_z
            ):  #:TODO:(?) compare distance between previous point and currPnt (not between eqPnt and currPnt)
                # The equilibrium point is not reached
                continue

            # Do a step of ESA (i.e. the equilibrium point is reached)
            doStep = True

            if nextStep == 'Step I.0' and doStep:
                printStep(tMainSim, nextStep, self.params.D)
                doStep = False

                D0 = self.params.D
                Q0 = Q_currPnt

                # Go to
                nextStep = 'Step I.1'
                sigma = 1
                self.params.D = D0 + sigma * h

            if nextStep == 'Step I.1' and doStep:
                printStep(tMainSim, nextStep, self.params.D)
                doStep = False

                D1 = self.params.D
                Q1 = Q_currPnt

                if Q1 > Q0:
                    # Go to
                    nextStep = 'Step I.3'
                    h = 2 * h
                    self.params.D = D1 + sigma * h
                else:
                    # Go to
                    nextStep = 'Step I.2'
                    sigma = -1.0
                    self.params.D = D0 - sigma * h

            if nextStep == 'Step I.2' and doStep:
                printStep(tMainSim, nextStep, self.params.D)
                doStep = False

                D1 = self.params.D
                Q1 = Q_currPnt

                if Q1 > Q0:
                    # Go to
                    nextStep = 'Step I.3'
                    h = 2 * h
                    self.params.D = D1 + sigma * h
                else:
                    h = h / 2.
                    if h <= eps / 2.:
                        # Go to
                        nextStep = 'Step III'
                        self.params.D = D0
                    else:
                        # Go to
                        nextStep = 'Step I.1'
                        sigma = 1
                        self.params.D = D0 + sigma * h

            if nextStep == 'Step I.3' and doStep:
                printStep(tMainSim, nextStep, self.params.D)
                doStep = False

                D2 = self.params.D
                Q2 = Q_currPnt

                if Q2 <= Q1:
                    D_minus = D0
                    D_plus = D2

                    # Go to
                    nextStep = 'Step II'
                    doStep = True
                else:
                    D0 = D1
                    Q0 = Q1

                    D1 = D2
                    Q1 = Q2

                    # Go to
                    nextStep = 'Step I.3'
                    h = 2 * h
                    self.params.D = D1 + sigma * h

            if nextStep == 'Step II' and doStep:
                printStep(tMainSim, nextStep, self.params.D)
                doStep = False

                D0_minus = D_minus
                D0_plus = D_plus
                print "Step II [D-, D+] = [", D0_minus, ", ", D0_plus, "]"

                dlt1 = D0_plus - D0_minus

                # Go to
                nextStep = 'Step II.0'
                doStep = True

            if nextStep == 'Step II.0' and doStep:
                printStep(tMainSim, nextStep, self.params.D)
                doStep = False

                dlt2 = (1 - lmbd) * dlt1

                D_p0 = D0_minus + dlt2
                D_q0 = D0_plus - dlt2

                # Go to
                nextStep = 'Step II.1.p0'
                self.params.D = D_p0

            if nextStep == 'Step II.1.p0' and doStep:
                printStep(tMainSim, nextStep, self.params.D)
                doStep = False

                D_p0 = self.params.D
                Q_p0 = Q_currPnt

                # Go to
                nextStep = 'Step II.1.q0'
                self.params.D = D_q0

            if nextStep == 'Step II.1.q0' and doStep:
                printStep(tMainSim, nextStep, self.params.D)
                doStep = False

                D_q0 = self.params.D
                Q_q0 = Q_currPnt

                # Go to
                nextStep = 'Step II.2'
                doStep = True

            if nextStep == 'Step II.2' and doStep:
                printStep(tMainSim, nextStep, self.params.D)
                doStep = False

                dlt3 = D_q0 - D_p0

                if Q_p0 > Q_q0:
                    D1_minus = D0_minus
                    D1_plus = D_q0
                    D_p1 = D1_minus + dlt3
                    D_q1 = D_p0
                    Q_q1 = Q_p0  #:TODO:(?) missing in pdf

                if Q_p0 <= Q_q0:
                    D1_minus = D_p0
                    D1_plus = D0_plus
                    D_p1 = D_q0
                    Q_p1 = Q_q0  #:TODO:(?) missing in pdf
                    D_q1 = D1_plus - dlt3

                dlt1 = D1_plus - D1_minus

                # Go to
                nextStep = 'Step II.3'
                doStep = True

            if nextStep == 'Step II.3' and doStep:
                printStep(tMainSim, nextStep, self.params.D)
                doStep = False

                print "Step II.3 [D1-, D1+] = [", D1_minus, ", ", D1_plus, "]"

                if dlt1 <= eps:
                    # Go to
                    nextStep = 'Step III'
                    self.params.D = (D1_minus + D1_plus) / 2.
                else:  # if dlt1 > eps:
                    if D_p1 >= D_q1:
                        D0_minus = D1_minus
                        D0_plus = D1_plus

                        # Go to
                        nextStep = 'Step II.0'
                        doStep = True
                    else:  # if D_p1 < D_q1:
                        if Q_p0 > Q_q0:
                            # Go to
                            nextStep = 'Step II.3.p1'
                            self.params.D = D_p1
                        else:  # if Q_p0 >= Q_q0:
                            # Go to
                            nextStep = 'Step II.3.q1'
                            self.params.D = D_q1

            if nextStep == 'Step II.3.p1' and doStep:
                printStep(tMainSim, nextStep, self.params.D)
                doStep = False

                D_p1 = self.params.D
                Q_p1 = Q_currPnt

                # Go to
                nextStep = 'Step II.3.1'
                doStep = True

            if nextStep == 'Step II.3.q1' and doStep:
                printStep(tMainSim, nextStep, self.params.D)
                doStep = False

                D_q1 = self.params.D
                Q_q1 = Q_currPnt

                # Go to
                nextStep = 'Step II.3.1'
                doStep = True

            if nextStep == 'Step II.3.1' and doStep:
                printStep(tMainSim, nextStep, self.params.D)
                doStep = False

                D_p0 = D_p1
                D_q0 = D_q1

                D0_minus = D1_minus
                D0_plus = D1_plus

                Q_p0 = Q_p1
                Q_q0 = Q_q1

                # Go to
                nextStep = 'Step II.2'
                doStep = True

            if nextStep == 'Step III' and doStep:
                printStep(tMainSim, nextStep, self.params.D)
                doStep = False

                QMaxIsFound = True

                # Set the ESA result
                self.ResESA_QMaxIsFound = QMaxIsFound
                self.ResESA_QMax = Q_currPnt
                self.ResESA_DMax = self.params.D

            #:TRICKY: limit the current seeking D value
            if self.params.D < self.params.ESA_DMin:
                self.params.D = self.params.ESA_DMin

            if self.params.D > self.params.ESA_DMax:
                self.params.D = self.params.ESA_DMax
Example #26
0
    def initState(self, params=None, **kwargs):
        if params == None:
            params = AttributeDict(kwargs)

        self.setState(params)
        self.compute()
Example #27
0
    def __init__(self, params = None, **kwargs):   
        if params == None:
            params = AttributeDict(kwargs)
        self.params = params
        
        #Calculate the equilibrium point
        def mu1(s, m, k):
            return (m*s)/(k + s)
        
        def mu2(s, m, k, k_I):
            return (m*s)/(k + s + (s/k_I)*(s/k_I))
        
        def eq_s1(s1, *args):
            (_k1, _k2, _k3, _s1_in, _s2_in, a, m1, _m2, k_s1, _k_s2, _k_I, D, _tau1, _tau2) = args
            return a*D - mu1(s1, m1, k_s1)
        
        def eq_s2(s2, *args):
            (_k1, _k2, _k3, _s1_in, _s2_in, a, _m1, m2, _k_s1, k_s2, k_I, D, _tau1, _tau2) = args
            return a*D - mu2(s2, m2, k_s2, k_I)
        
        eqs_args = (
            params.k1, params.k2, params.k3, 
            params.s1_in, params.s2_in, params.a, 
            params.m1, params.m2, 
            params.k_s1, params.k_s2, params.k_I, 
            params.D, params.tau1, params.tau2)
        
        s1_eqpnt = fsolve(eq_s1, 1.0, args = eqs_args)[0]
        x1_eqpnt = (params.s1_in - s1_eqpnt)/(params.a*params.k1)
        if x1_eqpnt < 0:
            s1_eqpnt = params.s1_in
            x1_eqpnt = 0.0
        
        s2_eqpnt_sol, _info, ier, _msg  = fsolve(eq_s2, 1.0, args = eqs_args, full_output = True)
        if ier != 1 or s2_eqpnt_sol[0] < 0:
            x2_eqpnt = 0.0
            s2_eqpnt = params.s2_in + params.k2*mu1(s1_eqpnt, params.m1, params.k_s1) * x1_eqpnt / params.D
        else:
            s2_eqpnt = s2_eqpnt_sol[0]
            x2_eqpnt = ((params.s2_in - s2_eqpnt)*params.D + params.k2*mu1(s1_eqpnt, params.m1, params.k_s1)*x1_eqpnt) \
                / (params.k3 * mu2(s2_eqpnt, params.m2, params.k_s2, params.k_I))
            
        self.equilibriumPoint = [s1_eqpnt, x1_eqpnt, s2_eqpnt, x2_eqpnt]
        if plotEqulibriumValuesAtTheEnd:
            print "equilibrium point (s1, x1, s2, x2) = ", self.equilibriumPoint
        
        # Define the specific growth rates (in 'C' source code)
        support_c_code = """
        double mu1(double s, double m, double k) {
            return (m*s)/(k + s);
        }
        
        double mu2(double s, double m, double k, double k_I) {
            return (m*s)/(k + s + (s/k_I)*(s/k_I));
        }
        """
        
        # Define the equations
        eqns = {
            's1': 'D*(s1_in - s1) - k1*mu1(s1, m1, k_s1)*x1',
            'x1': 'mu1(s1(t-tau1), m1, k_s1)*x1(t-tau1) - a*D*x1',
            's2': 'D*(s2_in - s2) + k2*mu1(s1, m1, k_s1)*x1 - k3*mu2(s2, m2, k_s2, k_I)*x2',
            'x2': 'mu2(s2(t-tau2), m2, k_s2, k_I)*x2(t-tau2) - a*D*x2'
        }
        
        # Define the parameters
        eqns_params = {
            'k1'    : params.k1,
            'k2'    : params.k2,
            'k3'    : params.k3,
            's1_in' : params.s1_in,
            's2_in' : params.s2_in,
            'a'     : params.a,
            'm1'    : params.m1,
            'm2'    : params.m2,
            'k_s1'  : params.k_s1,
            'k_s2'  : params.k_s2,
            'k_I'   : params.k_I,
            'D'     : params.D,
            'tau1'  : params.tau1,
            'tau2'  : params.tau2,
        }
        
        # Initialize the solver
        self.dde = dde23(eqns=eqns, params=eqns_params, supportcode=support_c_code)

        # Set the initial conditions (i.e. set the history of the state variables)
        histfunc = {
            's1': lambda t: params.s1_hist_vals,
            'x1': lambda t: params.x1_hist_vals,
            's2': lambda t: params.s2_hist_vals,
            'x2': lambda t: params.x2_hist_vals
            }
        self.dde.hist_from_funcs(histfunc, 10.) #:TRICKY: 10. is 'nn' - sample in the interval
Example #28
0
def TestADM1H2CH4Bioreactor():
    print "=== BEGIN: TestADM1H2CH4Bioreactor ==="

    # Settings
    simulate = True  #True - run simulation; False - plot an old results

    # Initialize simulation parameters
    solverParams = AttributeDict({
        'tFinal': 50.,
        'tPrint': .1,
        'absTol': 1e-9,
        'relTol': 1e-7,
    })

    # Initialize model parameters

    # Validation of prameters
    #f_su_li + f_fa_li <= 1.0
    #f_ch_xc + f_pr_xc + f_li_xc + [f_xI_xc + f_sI_xc] = 1.0
    #[f_bu_su + f_pro_su] + f_ac_su + f_h2_su = 1.0
    #[f_va_aa + f_bu_aa + f_pro_aa] + f_ac_aa + f_h2_aa = 1.0
    #Y_xx < = 1.0
    class ModelParamsRH2:
        #Stoichiometric parameter values
        f_ch_xc = 0.2  #-
        f_pr_xc = 0.2  #-
        f_li_xc = 0.3  #-

        f_su_li = 0.05  #-
        f_fa_li = 0.90  #-

        f_ac_su = 0.41  #-

        f_ac_aa = 0.4  #-

        Y_suaa = 0.1  #-
        Y_fa = 0.06  #-

        #Biochemical parameter values
        k_dis = 0.5  #1/day

        k_hyd_ch = 10.0  #1/day
        k_hyd_pr = 10.0  #1/day
        k_hyd_li = 10.0  #1/day

        k_m_suaa = 30.0  #1/day
        K_S_suaa = 0.5  #g/L

        k_m_fa = 6.0  #1/day
        K_S_fa = 0.4  #g/L

        #kLa_h2 = 200 #1/day
        Y_h2_su = 1.0  #-
        Y_h2_aa = 1.0  #-
        Y_h2_fa = 1.0  #-

        # Controller - D = q/V
        D_liq_arr = np.array([[10., 1.], [20., 2.]])  #[day, 1/day] (liquid)

    modelParamsRH2 = ModelParamsRH2()

    class ModelConcentrsRH2:
        # Input concentrations
        S_su_in = 0 * 0.01  #gCOD/L
        S_aa_in = 0 * 0.001  #gCOD/L
        S_fa_in = 0 * 0.001  #gCOD/L
        S_ac_in = 0 * 0.001  #gCOD/L
        X_c_in = 2.0  #gCOD/L
        X_ch_in = 5.0  #gCOD/L
        X_pr_in = 20.0  #gCOD/L
        X_li_in = 5.0  #gCOD/L
        X_suaa_in = 0 * 0.01  #g/L
        X_fa_in = 0 * 0.01  #g/L

        # Initial values of state variables
        S_su_0 = 0.01  #gCOD/L
        S_aa_0 = 0.001  #gCOD/L
        S_fa_0 = 0.001  #gCOD/L
        S_ac_0 = 0.001  #gCOD/L
        X_c_0 = 2.0  #gCOD/L
        X_ch_0 = 5.0  #gCOD/L
        X_pr_0 = 20.0  #gCOD/L
        X_li_0 = 5.0  #gCOD/L
        X_suaa_0 = 0.01  #g/L
        X_fa_0 = 0.01  #g/L

    modelConcentrsRH2 = ModelConcentrsRH2()

    webModel = AttributeDict({
        'updateProgress': lambda x, y: x,  #:TRICKY: not used,
    })

    class ModelParamsRCH4:
        #Stoichiometric parameter values
        Y_ac = 0.05  #-

        #Biochemical parameter values
        k_m_ac = 8.0  #1/day
        K_S_ac = 0.15  #g/L

        Y_ch4_ac = 1.0  #-

        # Physical parameters
        V_liq_RCH4_del_V_liq_RH2 = 5.

    modelParamsRCH4 = ModelParamsRCH4()

    class ModelConcentrsRCH4:
        # Input concentrations
        X_ac_in = 0 * 0.01  #g/L

        # Initial values of state variables
        S_ac_0 = 0.2  #gCOD/L
        X_ac_0 = 0.76  #g/L

    modelConcentrsRCH4 = ModelConcentrsRCH4()

    # Create the model
    bioreactor = ADM1H2CH4Bioreactors(webModel=webModel,
                                      paramsRH2=modelParamsRH2,
                                      concentrsRH2=modelConcentrsRH2,
                                      paramsRCH4=modelParamsRCH4,
                                      concentrsRCH4=modelConcentrsRCH4,
                                      initDataStorage=simulate)

    # Run simulation or load old results
    if (simulate == True):
        bioreactor.prepareSimulation(solverParams)
        bioreactor.run(solverParams)
    else:
        bioreactor.loadResult(simIndex=1)

    # Export to csv file
    bioreactor.resultStorage.exportToCsv(fileName=csvFileName)

    # Plot results
    bioreactor.plotHDFResults()

    print "=== END: TestADM1H2Bioreactor ==="
Example #29
0
    def __init__(self, params=None, **kwargs):
        if params == None:
            params = AttributeDict(kwargs)

        # Set the material
        if (isinstance(params.material, basestring)):
            self.material = Solids[params.material]
        elif (isinstance(params.material, dict)):
            self.material = params.material

        # Thermal conductivity params
        if ('thermalCond_T' in self.material):
            self.thermCondModel = Interpolator1D(
                xValues=self.material['thermalCond_T']['T'],
                yValues=self.material['thermalCond_T']['cond'])
        else:
            raise ValueError(
                "The material '{}' does not define a thermal conductivity params"
                .format(self.material.name))
        # Heat capacity params
        if ('heatCapacity_T' in self.material):
            self.cpModel = Interpolator1D(
                xValues=self.material['heatCapacity_T']['T'],
                yValues=self.material['heatCapacity_T']['cp'])
        else:
            raise ValueError(
                "The material '{}' does not define a thermal conductivity params"
                .format(self.material.name))

        # Mass
        if hasattr(params, 'mass'):
            self.mass = params.mass
        else:
            rho = self.material['refValues']['density']
            V = params.thickness * params.conductionArea
            self.mass = rho * V

        self.numMassSegments = params.numMassSegments
        self.segmentMass = self.mass / self.numMassSegments
        self.cp = np.zeros(self.numMassSegments)
        self.T = np.ones(self.numMassSegments) * params.TInit
        self.TDot = np.zeros(self.numMassSegments)

        # Conductions and end handling
        self.thickness = params.thickness
        self.numConductiveSegments = self.numMassSegments - 1
        if (params.port1Type in ['C', 'R']):
            if (params.port1Type == 'R'):
                self.numConductiveSegments += 1
        else:
            raise ValueError(
                "port1Type must be 'R' or 'C', value given is '{}'".format(
                    params.port1Type))
        if (params.port2Type in ['C', 'R']):
            if (params.port2Type == 'R'):
                self.numConductiveSegments += 1
        else:
            raise ValueError(
                "port2Type must be 'R' or 'C', value given is '{}'".format(
                    params.port2Type))

        if (self.numConductiveSegments > 0):
            self.segmentThickness = self.thickness / self.numConductiveSegments
            self.conductionArea = params.conductionArea
            self.cond = np.zeros(self.numConductiveSegments)
            self.QDot = np.zeros(self.numConductiveSegments)

        # Set up the port valriables
        if (params.port1Type == 'C'):
            self.port1 = DMS.ThermalPort(params.port1Type, DMS.ThermalState())
        else:
            self.port1 = DMS.ThermalPort(params.port1Type)

        if (params.port2Type == 'C'):
            self.port2 = DMS.ThermalPort(params.port2Type, DMS.ThermalState())
        else:
            self.port2 = DMS.ThermalPort(params.port2Type)
Example #30
0
def TestBiochemicalReactions():
    print "=== BEGIN: TestBiochemicalReactions ==="

    # Settings
    simulate = True  #True - run simulation; False - plot an old results

    # Initialize simulation parameters
    solverParams = AttributeDict({
        'tFinal': 20.,
        'tPrint': 0.01,
    })

    # Initialize model parameters
    dt = np.dtype([('reactionEquation', np.str_, 256),
                   ('rateConstants', np.str_, 256)])
    reactions = np.array([
        ("E + S = ES", "2., 1."),
        ("ES -> E + P", "1.5"),
    ],
                         dtype=dt)

    dt_vars = np.dtype([('speciesVariable', np.str_, 256),
                        ('initialValue', np.float64, (1))])
    species = np.array([
        ('E', 4.),
        ('S', 8.),
        ('ES', 0.0),
        ('P', 0.0),
    ],
                       dtype=dt_vars)

    modelParams = AttributeDict({
        'updateProgress': lambda x, y: x,  #:TRICKY: not used,
        'reactions': reactions,
        'species': species,
    })

    # Create the model
    model = BiochemicalReactions(modelParams)
    print model.getODEsTxt()

    fig = plt.figure()
    ax = fig.add_subplot(111)
    model.plotODEsTxt(ax)

    # Run simulation or load old results
    if (simulate == True):
        model.prepareSimulation()
        model.run(solverParams)
    else:
        model.loadResult(simIndex=1)

    # Export to csv file
    #model.resultStorage.exportToCsv(fileName = csvFileName)

    # Plot results
    fig = plt.figure()
    ax = fig.add_subplot(111)
    model.plotHDFResults(ax)

    print "=== END: TestBiochemicalReactions ==="