Пример #1
0
        // -------------------------------------------------------------------------------------
        //                              !!! PUBLIC METHODS !!!
        // -------------------------------------------------------------------------------------

        /// <summary>
        /// calc organic nitrogen in state vector x
        /// measured in k mol N/m3
        /// </summary>
        /// <param name="x">ADM1 state or stream vector</param>
        /// <param name="digester_id">ID of digester</param>
        /// <param name="myPlant"></param>
        /// <returns>organic nitrogen</returns>
        public static double calcNorg(double[] x, string digester_id, plant myPlant)
        {
            // get ADM1 parameters
            // das sind die zuletzt upgedateten Parameter, nicht die default Werte
            double[] ADM1params = myPlant.getDefaultADMparams(digester_id);

            //

            // TODO - funktioniert nicht mehr wenn sich Positionen in vektor verschieben

            // TODO in ADMstate_properties wurden Positionen definiert, diese nutzen!!!

            // amino acids [kg COD/m3]
            double Saa = x[pos_Saa - 1];

            // soluble inerts kg COD/m3
            double SI = x[11];
            // composite kg COD/m3
            double Xc = x[12];

            // proteins kg COD/m3
            double Xpr = x[14];

            double Xbio = calcBiomassOfADMstate(x).Value;

            // particulate inerts kg COD/m3
            double XI = x[23];
            // Particulate products arising from biomass decay kg COD/m^3
            double Xp = x[24];


            // TODO funktioniert nicht wenn ADM parameter sich verändern

            double fSI_XC = ADM1params[ADMparams.pos_fSI_XC - 1]; // fraction SI from XC

            double fCH_XC = ADM1params[ADMparams.pos_fCH_XC - 1]; // fraction Xch from XC
            double fPR_XC = ADM1params[ADMparams.pos_fPR_XC - 1]; // fraction Xpr from XC
            double fLI_XC = ADM1params[ADMparams.pos_fLI_XC - 1]; // fraction Xli from XC
            double fXP_XC = ADM1params[ADMparams.pos_fXP_XC - 1]; // fraction Xp from XC

            double fXI_XC = 1 - fSI_XC - fCH_XC - fPR_XC - fLI_XC - fXP_XC;

            double N_I  = ADM1params[7];
            double N_aa = ADM1params[8];

            double N_XB = ADM1params[23];

            double N_Xp = ADM1params[103];


            // calc Norg
            // alle Verbindungen, welche Kohlenstoff beinhalten nennt man organisch
            // die anderen anorganisch. Ausnahme sind Oxide wie bspw. CO2 und ein paar weitere
            // Ausnahmen. damit sind hier alle verbindungen organisch, bspw. auch SI und XI.

            double Norg = N_aa * (Saa + fPR_XC * Xc + Xpr) + N_Xp * (fXP_XC * Xc + Xp) +
                          N_XB * Xbio + N_I * (SI + XI + fSI_XC * Xc + fXI_XC * Xc);

            return(Norg);
        }
Пример #2
0
        /// <summary>
        /// calc NH3 in ADM1 state, this is the sum:
        /// Snh3 + NH3 in Xc, measured in kmolN/m^3
        /// </summary>
        /// <param name="x">ADM state vector</param>
        /// <param name="digester_id">digester ID</param>
        /// <param name="myPlant"></param>
        /// <returns>NH4</returns>
        public static double calcNH3(double[] x, string digester_id, plant myPlant)
        {
            // get ADM1 parameters
            // das sind die zuletzt upgedateten Parameter, nicht die default Werte
            double[] ADM1params = myPlant.getDefaultADMparams(digester_id);

            // TODO - funktioniert nicht mehr wenn sich Positionen in vektor verschieben

            // Ammonium k mol N/m3
            double Snh4 = x[10];

            // composite kg COD/m3
            double Xc = x[12];

            // Ammonia k mol N/m3
            double Snh3 = x[32];

            // enthält NH4 und NH3
            double fSIN_XC = ADM1params[6]; // ist immer 0


            // Verhältnis von NH3 zu NH4 im Fermenter, Annahme, dass es sich
            // mit NH3 und NH4 in Xc genauso verhält.
            //
            // Herl:
            // Nsumme= NH4 + NH3= fSIN_Xc * Xc =
            // = NH3 * (1 + 1/r_N3_N4)
            // NH3= Nsumme / (1 + 1/r_N3_N4)
            // TODO: kann C# eigentlich mit /0 rechnen? denke schon
            // wenn ja, gibt es hier kein Problem, ob Snh3 oder Snh4 0 ist ist egal
            // C# rechnet richtig, scheinbar doch nicht, deshalb abfragen unten
            double r_N3_N4 = Snh3 / Snh4;

            double NH3 = Snh3 + fSIN_XC * Xc / (1 + 1 / r_N3_N4);

            // TODO - das ist falsch - Faktor 0.1 hängt von pH Wert ab
            // NH3 ist dann eher fSIN_XC * Xc * faktor, faktor hängt aber vom pH Wert ab
            if (Snh3 == 0)                       // da wir dann durch unendlich geteilt haben, gibt es probleme
            {
                NH3 = Snh3 + fSIN_XC * Xc * 0.1; // 1/ unendlich scheint in C# nicht 0 zu sein, sondern evtl. n.def.
            }
            else if (Snh4 == 0)                  // da wir dann durch unendlich geteilt haben, gibt es probleme
            {
                NH3 = Snh3 + fSIN_XC * Xc * 0.1; // 1/ unendlich scheint in C# nicht 0 zu sein, sondern evtl. n.def.
            }
            return(NH3);
        }