Esempio n. 1
0
        /// <summary>
        /// Startet die Metall-Saeure Reaktion
        /// </summary>
        public override void BeginneReaktion()
        {
            // Erhalte die ionisierten Saeurevarianten der Saeure. Die Anzahl der Protonen
            // in der Saeure gibt die Anzahl der Varianten an, da jeweils Protonen im
            // Saeurerest sich anlagern koennen
            List <(Kation wasserstoffIon, Anion saeurerestIon)> saeureVariationen = ReagierendeSaeure.ErhalteIonisierteSaeurevarianten();

            // Generiere fuer jede Saerevariante eine Reaktionsgleichung
            foreach ((Kation wasserstoffIon, Anion saeurerestIon)saeureVariation in saeureVariationen)
            {
                // Ionisiere das Metall, damit ein Salz kreiert werden kann
                Kation metallIon = new Kation(new Molekuel(new Atombindung(ReagierendesMetall, 1), 1));

                // Generie das Salz aus dem ionisierten Metall + dem ionisierten
                // Saeurerest
                Salz salz = new Salz(metallIon, saeureVariation.saeurerestIon);

                // Erstelle die Wasserstoffbindung
                Atombindung wasserstoff = new Atombindung("H₂", "Wasserstoff");

                // Erstelle die Reaktionsstoffe mit den vorhandenen Bindungen.
                // Diese Klasse merkt sich zu den Bindungen auch die Anzahl
                // der Molekuele nach dem ausgleichen
                Reaktionsstoff wasserstoffKomponente = new Reaktionsstoff(wasserstoff);
                Reaktionsstoff metallKomponente      = new Reaktionsstoff(ReagierendesMetall);
                Reaktionsstoff saeureKomponente      = new Reaktionsstoff(ReagierendeSaeure);
                Reaktionsstoff salzKomponente        = new Reaktionsstoff(salz);

                // Die Anzahl der Metallkomponente entspricht der Anzahl der Metallatome
                // im Salz bei der Salzkreierung werden die Metall-Atome so gesetzt, dass
                // sie mit der Ladung des Saeurerestes uebereinstimmt
                metallKomponente.Anzahl = salz.Kation.Molekuel.AnzahlAtomeInMolekuel();

                // Die Anzahl der Saeurekomponente entspricht der Anzahl des
                // Saeurerest-Molekuels im Salz bei der Salzkreierung werden
                // die Saeurerest-Molekuele so gesetzt, dass sie mit der Ladung
                // des Metalls übereinstimmt
                saeureKomponente.Anzahl = salz.Anion.Molekuel.Anzahl;

                // Die Anzahl der Salzkomponente bleibt bei dieser Reaktion immer eins
                salzKomponente.Anzahl = 1;

                // Erhalte die Anzahl der Wasserstoffatome in der Saeure
                double maximaleWasserstoffAtome = saeureKomponente.Anzahl * ReagierendeSaeure.Wasserstoff.AnzahlAtomeInMolekuel();

                // Subtrahiere die Anzahl der Wasserstoffatome in der Saeure mit der
                // Anzahl der Wasserstoffatome im Salz um die restlichen
                // Wasserstoffatome für die Wasserstoffbindung H2 zu erhalten
                double restlicheWasserstoffAtome = maximaleWasserstoffAtome - (salzKomponente.Anzahl * salz.Anion.Molekuel.Anzahl * (ReagierendeSaeure.Wasserstoff.AnzahlAtomeInMolekuel() - saeureVariation.wasserstoffIon.Molekuel.AnzahlAtomeInMolekuel()));

                // Die Anzahl der Wasserstoffbindung H2 ergibt sich aus der Anzahl
                // Wasserstoffatomeder restlichen Wasserstoffatome / 2
                wasserstoffKomponente.Anzahl = restlicheWasserstoffAtome / 2;

                // Fuege der Liste der Reaktionen diese Reaktion hinzu
                ReaktionsResultate.Add(new MetallSaeureReaktionsResultat(metallKomponente, saeureKomponente, salzKomponente, wasserstoffKomponente));
            }
        }
Esempio n. 2
0
        public override void BeginneReaktion()
        {
            // Erhalte die ionisierten Saeurevarianten der Saeure. Die Anzahl der Protonen
            // in der Saeure gibt die Anzahl der Varianten an, da jeweils Protonen im
            // Saeurerest sich anlagern koennen
            List <(Kation wasserstoffIon, Anion saeurerestIon)> saeureVariationen = ReagierendeSaeure.ErhalteIonisierteSaeurevarianten();

            // Generiere fuer jede Saerevariante eine Reaktionsgleichung
            foreach ((Kation wasserstoffIon, Anion saeurerestIon)saeureVariation in saeureVariationen)
            {
                // Definiere die benoetigten Komponenenten, damit ihrer Anzahl gesezt werden kann
                Reaktionsstoff laugeKomponente  = new Reaktionsstoff(ReagierendeLauge);
                Reaktionsstoff saeureKomponente = new Reaktionsstoff(ReagierendeSaeure);

                Salz salz = null;
                // UeberprUefe, ob es sich bei der Lauge um Ammoniak handelt
                if (ReagierendeLauge is Ammoniak)
                {
                    // Es handelt sich bei der Lauge um Ammoniak
                    Ammoniak ammoniak = ReagierendeLauge as Ammoniak;

                    // Erstelle das Ammonium-Ion
                    Kation ammonium = new Kation(new Molekuel(new Atombindung("NH₄", "Ammonium"), 1), 1);

                    // Erstelle das Salz aus dem Ammonium-Ion und dem Saeurerest-Ion
                    salz = new Salz(ammonium, saeureVariation.saeurerestIon);

                    // Setze die Anzahl der Lauge gleich der Anzahl der Ammonium-Moeluele
                    laugeKomponente.Anzahl = salz.Kation.Molekuel.Anzahl;

                    // Erstelle die restlichen Reaktionsstoffe
                    Reaktionsstoff salzKomponente = new Reaktionsstoff(salz);

                    // Setze die Anzahl der restlichen Komponenten gleich eins
                    saeureKomponente.Anzahl = 1;
                    salzKomponente.Anzahl   = 1;

                    // Fuege der Liste der Reaktionen diese Reaktion hinzu
                    ReaktionsResultate.Add(new SaeureLaugeReaktionsResultat(saeureKomponente, laugeKomponente, salzKomponente, null));
                }
                else
                {
                    // Es handelt sich bei der Lauge um ein Metallhydroxid
                    Metall metall = ReagierendeLauge.Metall.Atombindung.ErhalteElement() as Metall;

                    // Erstelle das Metall-Ion
                    Kation metallIon = new Kation(new Molekuel(new Atombindung(metall, 1), 1));

                    // Erstelle das Salz aus dem Metall-Ion und dem Saeurerest-Ion
                    salz = new Salz(metallIon, saeureVariation.saeurerestIon);

                    // Erstelle die Wasserstoffbindung
                    Atombindung wasser = new Atombindung("H₂O", "Wasser");

                    // Erstelle die restlichen Reaktionsstoffe
                    Reaktionsstoff wasserKomponente = new Reaktionsstoff(wasser);
                    Reaktionsstoff salzKomponente   = new Reaktionsstoff(salz);

                    //Falls die Anzahl der Metall-Atome in der Lauge gleich dem im Salz sind
                    if (ReagierendeLauge.Metall.AnzahlAtomeInMolekuel() == salz.Kation.Molekuel.AnzahlAtomeInMolekuel())
                    {
                        // Die Anzahl der Metall-Atome in der Lauge, sowie im Salz sind identisch
                        // => Anzahl Lauge und Salz auf 1 setzen
                        laugeKomponente.Anzahl = 1;
                        salzKomponente.Anzahl  = 1;
                    }
                    //Falls die Anzahl der Metall-Atome in der Lauge groeßer dem im Salz sind
                    else if (ReagierendeLauge.Metall.AnzahlAtomeInMolekuel() > salz.Kation.Molekuel.AnzahlAtomeInMolekuel())
                    {
                        // Die Anzahl der Metall-Atome in der Lauge sind groeßer als die im Salz
                        // => Anzahl Lauge auf 1 setzen und die Anzahl des Salzes berechnen
                        laugeKomponente.Anzahl = 1;
                        salzKomponente.Anzahl  = ReagierendeLauge.Metall.AnzahlAtomeInMolekuel() / salz.Kation.Molekuel.AnzahlAtomeInMolekuel();
                    }
                    //Falls die Anzahl der Metall-Atome in der Lauge kleiner dem im Salz sind
                    else
                    {
                        // Die Anzahl der Metall-Atome in der Lauge sind geringer als die im Salz
                        // => Anzahl Lauge berechnen und die Anzahl des Salzes auf 1 setzen
                        laugeKomponente.Anzahl = salz.Kation.Molekuel.AnzahlAtomeInMolekuel() / ReagierendeLauge.Metall.AnzahlAtomeInMolekuel();
                        salzKomponente.Anzahl  = 1;
                    }

                    // Die Anzahl der Saeure entspricht die Anzahl des Saeurerest-Ions
                    // => Saeure um die Anzahl des Saeurerestions multiplizieren
                    saeureKomponente.Anzahl = salzKomponente.Anzahl * salz.Anion.Molekuel.Anzahl;

                    // Erhalte die Anzahl der Wasserstoffatome in der Saeure
                    double wasserstoffAtomeInSaeure = saeureKomponente.Anzahl * ReagierendeSaeure.Wasserstoff.AnzahlAtomeInMolekuel();
                    // Erhalte die Anzahl der Wasserstoffatome im Salz
                    double wasserstoffAtomeInSalz = salzKomponente.Anzahl * salz.Anion.Molekuel.Anzahl * ((saeureKomponente.Molekuel as Saeure).Wasserstoff.AnzahlAtomeInMolekuel() - saeureVariation.wasserstoffIon.Molekuel.AnzahlAtomeInMolekuel());
                    // Erhalte die Anzahl der Wasserstoffatome in der Lauge
                    double wasserstoffAtomeInLauge = laugeKomponente.Anzahl * ReagierendeLauge.Hydroxid.Anzahl;
                    // Subtrahiere die Wasserstoffatome im Salz von der Saeure + Lauge und
                    // teile es durch zwei, da H20 gleich zwei Wasserstoffatome pro Molekuel besitzt
                    wasserKomponente.Anzahl = (wasserstoffAtomeInSaeure + wasserstoffAtomeInLauge - wasserstoffAtomeInSalz) / 2;

                    // Fuege der Liste der Reaktionen diese Reaktion hinzu
                    ReaktionsResultate.Add(new SaeureLaugeReaktionsResultat(saeureKomponente, laugeKomponente, salzKomponente, wasserKomponente));
                }
            }
        }
        public override void BeginneReaktion()
        {
            // Erhalte die ionisierten Saeurevarianten der Saeure. Die Anzahl der Protonen
            // in der Saeure gibt die Anzahl der Varianten an, da jeweils Protonen im
            // Saeurerest sich anlagern koennen
            List <(Kation wasserstoffIon, Anion saeurerestIon)> saeureVariationen = ReagierendeSaeure.ErhalteIonisierteSaeurevarianten();

            // Generiere fuer jede Saerevariante eine Reaktionsgleichung
            foreach ((Kation wasserstoffIon, Anion saeurerestIon)saeureVariation in saeureVariationen)
            {
                // Erhalte das Metallelement aus dem Oxid und ionisiere es
                Metall metall    = ReagierendesMetalloxid.Bindungspartner.Atombindung.ErhalteElement() as Metall;
                Kation metallIon = new Kation(new Molekuel(new Atombindung(metall, 1), 1));

                // Bilde das Salz aus dem Metallion und dem ionisierten Saeurerest
                Salz salz = new Salz(metallIon, saeureVariation.saeurerestIon);

                // Erstelle die Wasserstoffbindung
                Atombindung wasser = new Atombindung("H₂O", "Wasser");

                // Erstelle die Reaktionsstoffe mit den vorhandenen Bindungen.
                // Diese Klasse merkt sich zu den Bindungen auch die Anzahl
                // der Molekuele nach dem Ausgleichen
                Reaktionsstoff metalloxidKomponente = new Reaktionsstoff(ReagierendesMetalloxid);
                Reaktionsstoff saeureKomponente     = new Reaktionsstoff(ReagierendeSaeure);
                Reaktionsstoff wasserKomponente     = new Reaktionsstoff(wasser);
                Reaktionsstoff salzKomponente       = new Reaktionsstoff(salz);

                //Falls die Anzahl der Metall-Atome im Oxid gleich dem im Salz sind
                if (ReagierendesMetalloxid.Bindungspartner.AnzahlAtomeInMolekuel() == salz.Kation.Molekuel.AnzahlAtomeInMolekuel())
                {
                    // Die Anzahl der Metall-Atome im Oxid, sowie im Salz sind identisch,
                    // => Anzahl des Metalloxids und des Salzes auf 1 setzen
                    metalloxidKomponente.Anzahl = 1;
                    salzKomponente.Anzahl       = 1;
                }
                //Falls die Anzahl der Metall-Atome im Oxid groeßer dem im Salz sind
                else if (ReagierendesMetalloxid.Bindungspartner.AnzahlAtomeInMolekuel() > salz.Kation.Molekuel.AnzahlAtomeInMolekuel())
                {
                    // Die Anzahl der Metall-Atome im Oxid sind groeßer als die im Salz
                    // => Anzahl des Metalloxids auf 1 setzen und die Anzahl des Salzes berechnen
                    metalloxidKomponente.Anzahl = 1;
                    salzKomponente.Anzahl       = ReagierendesMetalloxid.Bindungspartner.AnzahlAtomeInMolekuel() / salz.Kation.Molekuel.AnzahlAtomeInMolekuel();
                }
                //Falls die Anzahl der Metall-Atome im Oxid kleiner dem im Salz sind
                else
                {
                    // Die Anzahl der Metall-Atome im Oxid sind geringer als die im Salz
                    // => Anzahl des Metalloxids berechnen und die Anzahl des Salzes auf 1 setzen
                    metalloxidKomponente.Anzahl = salz.Kation.Molekuel.AnzahlAtomeInMolekuel() / ReagierendesMetalloxid.Bindungspartner.AnzahlAtomeInMolekuel();
                    salzKomponente.Anzahl       = 1;
                }

                // Die Anzahl der Saeure entspricht die Anzahl des Saeurerestions
                // => Saeure um die Anzahl des Saeurerestions multiplizieren
                saeureKomponente.Anzahl = salzKomponente.Anzahl * salz.Anion.Molekuel.Anzahl;

                // Erhalte die Anzahl der Wasserstoffatome in der Saeure
                double wasserstoffAtomeInSaeure = saeureKomponente.Anzahl * ReagierendeSaeure.Wasserstoff.AnzahlAtomeInMolekuel();
                // Erhalte die Anzahl der Wasserstoffatome im Salz
                double wasserstoffAtomeInSalz = salzKomponente.Anzahl * salz.Anion.Molekuel.Anzahl * ((saeureKomponente.Molekuel as Saeure).Wasserstoff.AnzahlAtomeInMolekuel() - saeureVariation.wasserstoffIon.Molekuel.AnzahlAtomeInMolekuel());
                // Subtrahiere die Wasserstoffatome in der Saeure mit dem des Salzes und
                // teile es durch zwei, da H20 gleich zwei Wasserstoffatome pro Molekuel besitzt
                wasserKomponente.Anzahl = (wasserstoffAtomeInSaeure - wasserstoffAtomeInSalz) / 2;

                // Fuege der Liste der Reaktionen diese Reaktion hinzu
                ReaktionsResultate.Add(new MetalloxidSaeureReaktionsResultat(metalloxidKomponente, saeureKomponente, salzKomponente, wasserKomponente));
            }
        }