Auf den Spuren des PH-Werts - Die Basics verstehen

Mal eine Frage an euch, habt ihr ggf. einen Bekannten der in Sachen Chemie relativ fit ist?

Und zwar hänge ich bei der Theoretischen Berechnung des pH-Wertes fest, also es gibt mehrere Annäherungen um das aus einer Lösung zu berechnen und auch wirklich viele Gleichungen dazu…

Eine Gleichung die GPT und meine Wenigkeit ausgeknobelt haben, lautet wie folgt:
pH = pKs + log10((Karbonathärte * Calciumhärte) / (Ks + (10^-pKs) * Calciumhärte + (10^-pKs) * Magnesiumhärte))

Alle Angaben darin sind in mmol/L gegeben, die Säure-Base Kapazität 4,3 ist praktisch die Karbonathärte, kann aber auch durch eine mg/L HCO3 Angabe geteilt durch 61.0168 mg/mmol selbst errechnet werden.

Die Calciumhärte ermitteln wir in dem wir die mg/L Ca-Angaben durch 40.0780 mg/mmol teilen und die Magnesiumhärte in dem die Mg-Angaben durch 24.305 mg/mmol teilen.

Und nun folgt das eigentliche Problem, unter der praktischen Verwendung eines pKs Wertes, der für Kohlensäure wohl unterschiedlicher Natur ist, von 3,6 bis 6,3 oder gar 10,3 laut Wiki, müssen wir das Ks errechnen.
GPT hat hier in Abhängigkeit der Temperatur noch etwas schönes für ein Skript erarbeitet:
ks = Math.pow(10, -(pks + 0.0141 * (25 - temp)))
wo temp die eingebene Temperatur ist, also praktisch 0 bei 25 Grad Celsius.

Das Ergebnis eines HTML-Skripts:

<!DOCTYPE html>
<html>
<head>
  <title>pH-Wert berechnen</title>
  <meta charset="UTF-8">
</head>
<body>
  <h1>pH-Wert berechnen</h1>
  <label>Karbonathärte oder auch SBK 4,3 (mmol/L):</label>
  <input type="number" id="karbonatharte"><br><br>
  <label>Calciumhärte (mmol/L):</label>
  <input type="number" id="calciumharte"><br><br>
  <label>Magnesiumhärte (mmol/L):</label>
  <input type="number" id="magnesiumharte"><br><br>
  <label>pKs Wert :</label>
  <input type="number" id="pKs"><br><br>
  <label>Wassertemperatur (°C) :</label>
  <input type="number" id="temp"><br><br>


  <button onclick="berechne_pH()">pH-Wert berechnen</button><br><br>
  <p id="ergebnis"></p>

  <script>
    function berechne_pH() {
      // Werte aus den Eingabefeldern lesen
      var kh = parseFloat(document.getElementById("karbonatharte").value);
      var ch = parseFloat(document.getElementById("calciumharte").value);
      var mh = parseFloat(document.getElementById("magnesiumharte").value);
	var pks = parseFloat(document.getElementById("pKs").value);// Säurekonstante für Kohlensäure
	var temp = parseFloat(document.getElementById("temp").value);// Temperatur des Wassers in °C
	var ks = Math.pow(10, -(pks + 0.0141 * (25 - temp)));
  	
      
      // Berechnung des pH-Werts
      
      var ph = pks + Math.log10((kh * ch) / (ks + Math.pow(10, -pks) * ch + Math.pow(10, -pks) * mh));

      // Ergebnis anzeigen
      document.getElementById("ergebnis").innerHTML = "pH-Wert: " + ph.toFixed(2);
    }
  </script>
</body>
</html>
[details="Zusammenfassung"]
Dieser Text wird ausgeblendet
[/details]

Das Problem zu begreifen ist das ich nur auf einen 8 pH Wert komme, wenn ich auch den pKs auf 4,3 festlege, ob hier eben ggf. durch die Karbonathärte die ebenfalls bei einem pH Wert 4,3 ermessen wurde, es eben zu Konflikten meiner Sichtweisen kommt! :sweat_smile:

Das der pH-Wert bei kälterem Wasser nach oben und bei wärmeren Wasser nach unten geht, ist laut Fachaussagen so korrekt, also liegt es an dem errechneten Ks Wert wohl eher weniger.

Ich hoffe ihr könnt mir etwas folgen, aber ich wollte mal wieder den Beitrag dahinbringen wo Gernot ihn gern sehen würde ^^.

LG Kushi

3 „Gefällt mir“

Ich muss sagen, dass ich aktuell eher still mitlese, weil die Diskussion meinen Wissenshorizont übersteigt :slight_smile:

Aber wenn Du die Spuren des PH-Werts zu ihrer Quelle zurückverfolgen kannst, um dann ihr Geheimnis zu lüften, dann werde ich ein Heureka ausrufen :smiley:

2 „Gefällt mir“

Ich muss einfach sagen, dass ich z.Zt gar keinen Kopf habe zu versuchen das alles hier nachzuvollziehen. Weil die Texte auch immer echt lang sind :sweat_smile:

Aber allen Growmies hier fetten Respekt!

2 „Gefällt mir“

Hab meinen PH-Wert mit einem sanften Flush aus Wasser (6,7) + 8ml/L schwarzer Melasse (alkalin) jetzt wieder bei 6,4 stabilisieren können.

Hört sich im Vergleich zu den Chemikern hier zwar an wie Steine zusammenklopfen aber is für andere Grower auf Erde eventuell ganz interessant :sweat_smile: :wink:

1 „Gefällt mir“

Achso ok, ich dachte schon du bist ausgestiegen und denkst dir, wie hat sich denn nur dieser Beitrag hier entwickelt… :joy:

Aber ich muss jetzt leider auch preisgeben das ich in Sachen der theoretischen pH-Wert Berechnung einfach raus bin! :upside_down_face:
Ich habe mich jetzt etliche Stunden ausführlich mit GPT unterhalten und ich weis das man nach der Debey Hückel Gleichung, also eine der genausten Berechnungen für den pH Wert, wohl den pH-Wert theoretisch berechnen könnte, aber ich bekomme es nicht auf die Kette!

Es ist im Grunde immer noch der pKs Wert der mir ein Dorn im Auge ist, ich weis das man ihn anhand des Ks Wertes über die Ionenstärke berechnen kann, aber alle Berechnungen verlaufen sich im Sande oder werden zunehmen bei wiederholten Eingaben widersprüchlicher! :sweat_smile:

Dennoch bin ich soweit gekommen und teile hier auch mal mein Skript für die Nachwelt:

Zusammenfassung

<!DOCTYPE html>
<html>
<head>
	<title>pH-Berechnung</title>
</head>
<body>
	<h1>pH-Berechnung</h1>

	<form id="inputForm">
		<label for="pksInput">pKs:</label>
		<input type="number" id="pksInput" name="pks" min="0" step="0.01" required><br>

		<label for="tempInput">Temperatur (°C):</label>
		<input type="number" id="tempInput" name="temp" min="0" max="100" step="0.1" required><br>

		<label for="caInput">Säure Base Kapazität Ks4,3 (mmol/L):</label>
		<input type="number" id="sbkInput" name="sbk" min="0" step="0.01" required><br>

		<label for="caInput">Calciumgehalt (mg/L):</label>
		<input type="number" id="caInput" name="ca" min="0" step="0.01" required><br>

		<label for="mgInput">Magnesiumgehalt (mg/L):</label>
		<input type="number" id="mgInput" name="mg" min="0" step="0.01" required><br>

		<label for="mgInput">Kalium (mg/L):</label>
		<input type="number" id="kInput" name="k" min="0" step="0.01" required><br>
		
		<label for="mgInput">Natrium (mg/L):</label>
		<input type="number" id="naInput" name="na" min="0" step="0.01" required><br>

		<label for="mgInput">Eisen (mg/L):</label>
		<input type="number" id="feInput" name="fe" min="0" step="0.0001" required><br>


		<input type="submit" value="Berechnen">
	</form>

	<p id="ergebnis"></p>

	<script>
		document.getElementById("inputForm").addEventListener("submit", function(event) {
			event.preventDefault();
			var pks = parseFloat(document.getElementById("pksInput").value);
			var temp = parseFloat(document.getElementById("tempInput").value);
			var sbk = parseFloat(document.getElementById("sbkInput").value);
			var ca = parseFloat(document.getElementById("caInput").value);
			var mg = parseFloat(document.getElementById("mgInput").value);
			var k = parseFloat(document.getElementById("kInput").value);
			var na = parseFloat(document.getElementById("naInput").value);
			var fe = parseFloat(document.getElementById("feInput").value);
			var ks = Math.pow(10, -(pks + 0.0141*(25 - temp)));
			var caMmol = ca / 40.0780;
			var mgMmol = mg / 24.305;
			var kMmol = k / 39.098;
			var naMmol = na / 22.989;
			var feMmol = fe / 55.845;
			var HCO3 = sbk - 0.05; 			
			var khMmol = HCO3 * 0.5;
			
			
			var ph = pks + Math.log10((2.5 * khMmol * caMmol) / (ks + Math.pow(10, -pks) * caMmol + Math.pow(10, -pks) * mgMmol + 				Math.pow(10, -pks) * naMmol + Math.pow(10, -pks) * kMmol + Math.pow(10, -pks) * feMmol));
			// Ergebnis anzeigen
      		document.getElementById("ergebnis").innerHTML = "pH-Wert: " + ph.toFixed(2);

			
		});
	</script>
</body>
</html>

Die Formel sollte so korrekt klingen, allerdings geht man auch davon aus, das überwiegend nur Calcium zur Karbonathärte im Vordergrund steht und es auch viele Wege gibt die Karbonathärte zu berechnen. Ich habe mehrere Ansätze verfolgt, von der Alkanität bis hin zur Säure Base Kapazität Ks 4,3, aber Formeln und Faktoren hin oder her, ich verzweifel daran förmlich und verstehe es nicht richtig! :face_with_spiral_eyes:

Nun gut, soviel zu meinem Statusbericht, ich wünsche dir bzw. euch allen eine Frohe Oster! :metal:

3 „Gefällt mir“

Ja, drei: Kugel, Gernot und dich :sweat_smile:
Sonst habe ich dir den Link zu einem mit mehr Expertise eigentlich schon gegeben:

My name is Dr. Daniel Fernandez. I have a bachelor’s degree in chemistry and a masters and Ph.D. in nanoscience and nanotechnology. I have a strong interest in plants and hydroponic crops.

Er hat auch den Hydrobuddy geschrieben. Kannst ihn über seine Seite öffentlich über die Kommentare erreichen oder ihn eine mail schreiben.
Bei deiner Berechnung bin ich gerade auch raus, aber mit ihm könntest du da sicher weiter kommen. Wie schon gesagt, die Berechnung die du da gerade machst, findest du auch hier.
Musst du dann halt mal durch, dass du auf englisch kommunizieren musst :slightly_smiling_face:

3 „Gefällt mir“

Das ist genau das, was ich mit Ionenstärke meinte, wo dann ein Ks Wert aber auch folgend der pKs Wert mit ermittelt werden kann. :upside_down_face:

Es geht halt darum diese nachfolgenden Konstanten da noch mit reinzubringen:
oh = 1.9910^-8
co3 = 1.04
10^-9
hco3 = 1.1110^-5
h2co3 = 2.24
10^-8
base = 1.07*10^-5

Also erst das Ionen Produkt zu erstellen, dann den Ks daraus berechnen und folgend aus dem Ks dann den pKs Wert errechnen usw. aber das ist leider zu hoch für mich!
Er hatte mir sowas schon erstellt, aber es funktionierte nicht! :slightly_smiling_face:
Typische Eingaben sind halt:
Ca = 15 mg/L
Mg = 8 mg/L
K = 2 mg/L
Na = 3 mg/L
SBK = 1,1 mmol/L
HCO3 = 67 mg/L

Mehr Werte hast du ja nicht und diese sollten eigentlich auch ausreichend sein um theoretisch in Kombination der anderen Faktoren einen möglichst theoretisch genau berechneten pH-Wert auszugeben.

Alleine schon die Ansicht der Alkanität sprengte es, weil was meinen sie mit Calciumhärte oder Magnesiumhärte etc.
KH (als CaCO3) = (15,5 mg/L * 2,5) + (8,4 mg/L * 4,1)
Es gibt aber noch weitere Alkanitäten wie die der Gesamthärte und auch der Hydrogencarbonathärte.
Gesamthärte = KH CaCO3 (mg/L) * 2
Hydrogencarbonathärte (HCO3-) = (Alkalität der Gesamthärte in mg CaCO3/L) - (Karbonathärte in mg CaCO3/L)

Also, wenn nun folgend von einer Karbonathärte oder einer Gesamthärte gesprochen wird, kann es seitens der Berechnung zu echte Komplikationen führen!

Auch von der Säure Base Kapazität Ks 4,3 gibt es Möglichkeiten die Karbonathärte zu ermitteln:
HCO3- in mmol/L = KS4,3 (mmol/L) - 0,05
KH in mmol/L = HCO3 (mmol/L) x 0,5

Du siehst selbst, ich komme nie auf den gleichen Nenner der Karbonathärte! :rofl:

Ich werde mich ggf. mal versuchen mich mit dem HydroBuddy Kollegen zu unterhalten, mal schauen was dabei rauskommt…

LG

3 „Gefällt mir“

Dito :grin:

Naja, da fehlt noch etwas. NO3-, die Phosphor-Formen, S, usw… Bringt ja alles eine Ladung mit und verändert den pH-Wert.
GPT sagte mir irgendwie auch, dass man nur aus Kationen und Anionen den pH berechnen können müsste. Nur war ihre Kalkulation totaler Mist. Komplizierte Rechenaufgaben kann das LLM halt noch nicht so gut (Es war bei einer älteren Version schon ein Durchbruch, dass die 1+1 richtig rechnen konnte) :wink:
Wie du sagst: Etwas vereinfacht würde ja reichen. Würde gerne eine Funktion haben, die mir bei Zugabe von Säure im Rechnen sagt, wie sehr sich das ungefähr auf den pH auswirkt.

Würde aber einfach mal auf GPT5 oder so warten. Wenn die sich so weiterentwickeln, kann die KI auch bald sowas richtig lösen.
Wir testen auch die KI im Moment, nicht sie uns. Seht das als riesige Sandbox - mmn die beste, mit der ich je spielen durfte bisher :smiling_face_with_three_hearts:

1 „Gefällt mir“

Natürlich spielen alle Enthaltenen ein, jedoch sagt GPT-Schrotthaufen da meist etwas anderes zu! :upside_down_face:
Es ist vernachlässigbar Klein… jaja!

Es vertut sich schon in kleinen simplen Dingen wie die Menge an Calcium mal einen Faktor 2,5 zu nehmen und dann als Calciumhärte CaCO3 auszugeben und ist felsenfest sicher, das Ca durch die Molmasse genommen wird und daraus die Calciumhärte entsteht, bis man ihm eine auf die Ohren gibt, wie war da nicht noch ein 2,5 Faktor!?

Ich habe mich bemüht um es nach den Si-Einheiten richtig zu stellen:

Zusammenfassung
<!DOCTYPE html>
<html>
<head>
	<title>pH-Berechnung</title>
</head>
<body>
	<h1>pH-Berechnung</h1>

	<form id="inputForm">
		<label for="pksInput">pKs:</label>
		<input type="number" id="pksInput" name="pks" min="0" step="0.01" required><br>

		<label for="tempInput">Temperatur (°C):</label>
		<input type="number" id="tempInput" name="temp" min="0" max="100" step="0.1" required><br>

		<label for="caInput">Calciumgehalt (mg/L):</label>
		<input type="number" id="caInput" name="ca" min="0" step="0.01" required><br>

		<label for="mgInput">Magnesiumgehalt (mg/L):</label>
		<input type="number" id="mgInput" name="mg" min="0" step="0.01" required><br>

		<input type="submit" value="Berechnen">
	</form>

	<p id="ergebnis"></p>

	<script>
		document.getElementById("inputForm").addEventListener("submit", function(event) {
			event.preventDefault();
			var pks = parseFloat(document.getElementById("pksInput").value);
			var temp = parseFloat(document.getElementById("tempInput").value);
			var ca = parseFloat(document.getElementById("caInput").value);
			var mg = parseFloat(document.getElementById("mgInput").value);
			var ks = Math.pow(10, -(pks + 0.0141*(25 - temp))); // Ks mit Temperturkoffizienten berechnen
			var caco3 = ca * 2.5; // Umrechnung zu CaCO3 Calciumhärte
			var mgco3 = mg * 4.1; // Umrechnung zu MgCO3	Magnesiumhärte
			var caco3Mmol = caco3 / 100.0869; // CaCO3 Umrechnung in mmol
			var mgco3Mmol = mgco3 / 84.3139; // MgCO3 Umrechnung in mmol
			var khMmol = caco3Mmol + mgco3Mmol; // Karbonathärte gesamt
			
			var ph = pks + Math.log10((khMmol * caco3Mmol) / (ks + Math.pow(10, -pks) * caco3Mmol + Math.pow(10, -pks) * mgco3Mmol));

			// Ergebnis anzeigen
      		document.getElementById("ergebnis").innerHTML = "pH-Wert: " + ph.toFixed(2);

			
		});
	</script>
</body>
</html>

Kurz gesagt, diese Formel sollte eigentlich passen und wurde von mir gut umgesetzt:
pH = pKs + log10((Karbonathärte * Calciumhärte) / (Ks + (10^-pKs) * Calciumhärte + (10^-pKs) * Magnesiumhärte))

Die SBK 4,3 zu einem KH Wert umzurechnen lassen wir lieber gleich GPT zu fragen, denn man kann ihn ohne eine Konzentration einer CO32 nicht errechnen, obwohl es es geht, er dann aber nach erneutem nachfragen einsieht das er wohl Misst gebaut hat und doch davon absieht!
In der Regel spricht man von * 0,5 um HCO3 und CO32 zu splitten weil es ja geteilt durch 2 ist und man hätte dann auch die wirkliche Karbonathärte inklusive ggf. auch der Schein-Karbonathärte usw. weil es ab pH-Wert 4,3 keine andere Möglichkeit mehr gibt!

Nunja, also teste das Skript mal aus und spiel mal mit dem pKs Wert rum, wenn er einheitlich bei euch auch 4,3 ist, wird er annähern so fest übernommen! :joy:

3 „Gefällt mir“

Von der Logik her müsste das auch klappen, finde ich.

Ich arbeite jetzt schon ne Weile mit meinen selbst ausgedachten Ladungsbilanzen und habe damit schon Fortschritte machen können. Ich kann den PH nicht berechnen, aber ich kann Wertbereiche eingrenzen, bei denen die Lösung in jedem Fall entweder zu sauer oder zu basisch ist.

ionen

ladungx1000

Wenn mein Wert „Ionenladung X 1000“ in einem Bereich von -5 bis -13 liegt ist der PH-Wert zumindest meistens in der Range zwischen 5,7 und 6,4.

Dass es nur partiell korrelieren kann ist klar, nachdem die Ionensumme linear verläuft und der PH-Wert per Definition logarithmisch ist.

Aber so jetzt nach 2 Monaten mit diesen Werten groovt sichs ganz gut ein, obwohl ich (bewusst) einige Ionen weggelassen habe.

5 „Gefällt mir“

Dort wo du bist will ich auch noch hin! :upside_down_face:
Aber nun gut, man muss es halt alles coden und das ist eine Menge Arbeit! :face_exhaling:

Ich kann jetzt grade mal mit einem fertigen Skript der Wasseranalyse dienen, die seitens von mir immer wieder noch verbessert werden muss aber auch bestimmt wird!

Die Funktionen bis jetzt sind:

  1. Angaben in mmol/L in mg/L umrechnen
  2. Karbonathärte und Gesamthärte berechnen
  3. Theoretischer Leitwert bei 25 Grad Celsius berechnen
  4. Alle wichtigen Werte in eine CSV Datei abspeichern um sie anschließend weiterzuverwenden

Ist halt eine Menge Code bis jetzt der echt viel Zeit verschlungen hat, aber ich bin stolz auf die kleinen Erfolge! :blush:

Nunja, hier mal das Skript:

Zusammenfassung
<!DOCTYPE html>
<html lang="de">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Wasserwerte</title>
</head>
<body>
    <h1>Nährstoffrechner 1.1 by KushMuss</h1>
    <h2>Eingabe und Verarbeitung der Wasserwerte in den typischen Angaben eines Wasserversorgers Ihrer Region.</h2>
    <h4>Wenn Sie keine Angaben über eine Konzentration eines gelisteten Stoffes besitzen, müssen Sie nur ein Eingabefeld mit einer Null versehen und nicht beide,
		jedoch Muss zu jedem der gelisteten Stoffe eine Eingabe erfolgen um die Berechnung starten zu können!</h4>   
	<p>Geben Sie hier die Konzentrationen der folgenden "Makronährstoffe" ein:</p>
    <style>
		table {
		  border-spacing: 5px; /* Abstand zwischen den Zellen für dicke Dumen aufm Schmatzphone*/
		  text-align: center; /* Alle Texte zentrieren */
		}
	  </style>
	<table>
        <thead>
          <tr>
            <th>Nährstoff</th>
            <th>mg/L</th>
            <th>mmol/L</th>
            <th>Ergebnis</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td>Nitrat NO3</td>
            <td><input type="number" id="Nitrat-mg" /></td>
            <td><input type="number" id="Nitrat-mmol" /></td>
            <td><span id="Nitrat-ergebnis"></span></td>
          </tr>
          <tr>
            <td>Ammonium NH4</td>
            <td><input type="number" id="Ammonium-mg" /></td>
            <td><input type="number" id="Ammonium-mmol" /></td>
            <td><span id="Ammonium-ergebnis"></span></td>
          </tr>
          <tr>
            <td>Phosphat PO4</td>
            <td><input type="number" id="Phosphat-mg" /></td>
            <td><input type="number" id="Phosphat-mmol" /></td>
            <td><span id="Phosphat-ergebnis"></span></td>
          </tr>
          <tr>
            <td>Kalium K</td>
            <td><input type="number" id="Kalium-mg" /></td>
            <td><input type="number" id="Kalium-mmol" /></td>
            <td><span id="Kalium-ergebnis"></span></td>
          </tr>
          <tr>
            <td>Calcium Ca</td>
            <td><input type="number" id="Calcium-mg" /></td>
            <td><input type="number" id="Calcium-mmol" /></td>
            <td><span id="Calcium-ergebnis"></span></td>
          </tr>
		  <tr>
            <td>Magnesium Mg</td>
            <td><input type="number" id="Magnesium-mg" /></td>
            <td><input type="number" id="Magnesium-mmol" /></td>
            <td><span id="Magnesium-ergebnis"></span></td>
          </tr>
          
		  <tr>
            <td>Sulfat SO4</td>
            <td><input type="number" id="Sulfat-mg" /></td>
            <td><input type="number" id="Sulfat-mmol" /></td>
            <td><span id="Sulfat-ergebnis"></span></td>
          </tr>
        </tbody>
      </table>
	
    <p>Geben Sie hier die Konzentrationen der folgenden "Mikronährstoffe" ein:</p>
    <table>
        <thead>
          <tr>
            <th>Nährstoff</th>
            <th>mg/L</th>
            <th>mmol/L</th>
            <th>Ergebnis</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td>Eisen Fe</td>
            <td><input type="number" id="Eisen-mg" /></td>
            <td><input type="number" id="Eisen-mmol" /></td>
            <td><span id="Eisen-ergebnis"></span></td>
          </tr>
          <tr>
            <td>Mangan Mn</td>
            <td><input type="number" id="Mangan-mg" /></td>
            <td><input type="number" id="Mangan-mmol" /></td>
            <td><span id="Mangan-ergebnis"></span></td>
          </tr>
          <tr>
            <td>Zink Zn</td>
            <td><input type="number" id="Zink-mg" /></td>
            <td><input type="number" id="Zink-mmol" /></td>
            <td><span id="Zink-ergebnis"></span></td>
          </tr>
          <tr>
            <td>Kupfer Cu</td>
            <td><input type="number" id="Kupfer-mg" /></td>
            <td><input type="number" id="Kupfer-mmol" /></td>
            <td><span id="Kupfer-ergebnis"></span></td>
          </tr>
          <tr>
            <td>Molybdän Mo</td>
            <td><input type="number" id="Molybdän-mg" /></td>
            <td><input type="number" id="Molybdän-mmol" /></td>
            <td><span id="Molybdän-ergebnis"></span></td>
          </tr>
          <tr>
            <td>Bor B</td>
            <td><input type="number" id="Bor-mg" /></td>
            <td><input type="number" id="Bor-mmol" /></td>
            <td><span id="Bor-ergebnis"></span></td>
          </tr>
          <tr>
            <td>Chlorid Cl</td>
            <td><input type="number" id="Chlorid-mg" /></td>
            <td><input type="number" id="Chlorid-mmol" /></td>
            <td><span id="Chlorid-ergebnis"></span></td>
          </tr>
          <tr>
            <td>Nickel Ni</td>
            <td><input type="number" id="Nickel-mg" /></td>
            <td><input type="number" id="Nickel-mmol" /></td>
            <td><span id="Nickel-ergebnis"></span></td>
          </tr>
          <tr>
            <td>Cobalt Co</td>
            <td><input type="number" id="Cobalt-mg" /></td>
            <td><input type="number" id="Cobalt-mmol" /></td>
            <td><span id="Cobalt-ergebnis"></span></td>
          </tr>        
        </tbody>
      </table>
    <p>Geben Sie hier die Konzentrationen der folgenden "Nur bedingt Nützlichen-Nährstoffe" ein:</p>
    <table>
        <thead>
          <tr>
            <th>Nährstoff</th>
            <th>mg/L</th>
            <th>mmol/L</th>
            <th>Ergebnis</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td>Natrium Na</td>
            <td><input type="number" id="Natrium-mg" /></td>
            <td><input type="number" id="Natrium-mmol" /></td>
            <td><span id="Natrium-ergebnis"></span></td>
          </tr>
          <tr>
            <td>Aluminium Al</td>
            <td><input type="number" id="Aluminium-mg" /></td>
            <td><input type="number" id="Aluminium-mmol" /></td>
            <td><span id="Aluminium-ergebnis"></span></td>
          </tr>
          <tr>
            <td>Silizium SiO2</td>
            <td><input type="number" id="Silizium-mg" /></td>
            <td><input type="number" id="Silizium-mmol" /></td>
            <td><span id="Silizium-ergebnis"></span></td>
          </tr>
        </thead>
        <tbody>
    </table>
    <p>Geben Sie hier die Art und die Konzentrationen der "Karbonate" an:</p>
    <table>
      <thead>
        <tr>
          <th>Angabe</th>
          <th>mg/L</th>
          <th>mmol/L</th>
          <th>KH dH°</th>
          <th>HCO3 mg/L</th>
        </tr>
      </thead>
      <tbody>
		<tr>
			<td>Calciumkarbonate CaCO3</td>
			<td><input type="number" id="CaCarbo-mg" /></td>
			<td><input type="number" id="CaCarbo-mmol" /></td>
			<td><span id="CaCarboKH-ergebnis"></span></td>
			<td><span id="CaCarbo-ergebnis"></span></td>
		  </tr>
        <tr>
          <td>Hydrocarbonate HCO3</td>
          <td><input type="number" id="Hydrocarbo-mg" /></td>
          <td><input type="number" id="Hydrocarbo-mmol" /></td>
          <td><span id="Hydrocarbo-dH-ergebnis"></span></td>
          <td><span id="Hydrocarbo-ergebnis"></span></td>
        </tr>
        <tr>
          <td>Säure-Base Kapazität 4,3</td>
          <td></td>
          <td><input type="number" id="SBK-mmol" /></td>
          <td><span id="SBK-KH-ergebnis"></span></td>
          <td><span id="SBK-ergebnis"></span></td>
        </tr>
        <tr>
          <td>Karbonathärte</td>
          <td></td>
          <td></td>
          <td><input type="number" id="Karbo-dH" /></td>
          <td><span id="Karbo-ergebnis"></span></td>		  
        </tr>
      </thead>
      <tbody>
    </table>
	<p>Klicke nun auf den Button Berechnen, um nachfolgend die Ergebnisse einzusehen und dann auf Speichern um die Werte weiter übernehmen zu können:</p>  
    
    <button onclick="berechnen()">Berechnen</button> 
	<button onclick="downloadCSV()">Speichern</button>
	
	<p>Die hier im nachfolgend ermittelten Gesamtionen und deren Verhältnis sowie der berechnete Leitwert ergeben sich aus diesen Eingaben:</p>
	<table>
		<thead>
		  <tr>
			<th>Übersicht</th>
			<th>Ergebnis</th>
		  </tr>
		</thead>
		<tbody>
		    <tr>
			  <td>Kationen Gesamt</td>
			  <td><span id="KatGes-ergebnis"></span></td>
			</tr>
			<tr>
				<td>Anionen Gesamt</td>
				<td><span id="AniGes-ergebnis"></span></td>
			</tr>
			<tr>
				<td>Anion / Kation Verhältnis</td>
				<td><span id="AniKatVer-ergebnis"></span></td>
			</tr>
			<tr>
				<td>Gesamthärte aus Ca & Mg</td>
				<td><span id="GesHärte-ergebnis"></span></td>
			</tr>
			<tr>
				<td>Leitwert bei 25°C</td>
				<td><span id="Leitwert-ergebnis"></span></td>
			</tr>
			
			

		<tbody>
		</thead>	
	</table>
</body>

<script>
    function berechnen() {     
		
    // Nitrat Ergebnisse berechnen
			var Nitrat_mg = parseFloat(document.getElementById("Nitrat-mg").value);
			var Nitrat_mmol = parseFloat(document.getElementById("Nitrat-mmol").value);
			// Überprüft ob die Felder leer sind
			if (isNaN(Nitrat_mg) && isNaN(Nitrat_mmol)) {
				alert("Bitte in einem Eingabefeld von Nitrat den Mindestwert 0 eintragen");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Nitrat_mg) && !isNaN(Nitrat_mmol)) {
				var Nitrat_mol = Nitrat_mmol / 1000; // mmol/L in mol/L umrechnen
				var Nitrat_mol_Grundmasse = Nitrat_mol * 62004.9; // mol/L in mg/L umrechnen
				var Nitrat_mg_Grundmasse = Nitrat_mg; // mg/L bleibt mg/L
				var Nitrat_ergebnis = Nitrat_mg_Grundmasse + Nitrat_mol_Grundmasse;
			}
			else if (!isNaN(Nitrat_mg)) {
				var Nitrat_ergebnis = Nitrat_mg;
			}
			else if (!isNaN(Nitrat_mmol)) {
				var Nitrat_mol = Nitrat_mmol / 1000; // mmol/L in mol/L umrechnen
				var Nitrat_mg_Grundmasse = Nitrat_mol * 62004.9; // mol/L in mg/L umrechnen
				var Nitrat_ergebnis = Nitrat_mg_Grundmasse;
			}
			// Gibt das Ergebnis aus
			document.getElementById("Nitrat-ergebnis").innerHTML = Nitrat_ergebnis.toFixed(2) + " mg/L";
            
        
	  // Ammonium Ergebnisse berechnen
			var Ammonium_mg = parseFloat(document.getElementById("Ammonium-mg").value);
			var Ammonium_mmol = parseFloat(document.getElementById("Ammonium-mmol").value);
			// Überprüft ob die Felder leer sind
			if (isNaN(Ammonium_mg) && isNaN(Ammonium_mmol)) {
				alert("Bitte in einem Eingabefeld von Ammonium den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Ammonium_mg) && !isNaN(Ammonium_mmol)) {
				var Ammonium_mol = Ammonium_mmol / 1000; // mmol/L in mol/L umrechnen
				var Ammonium_mol_Grundmasse = Ammonium_mol * 18038.46; // mol/L in mg/L umrechnen
				var Ammonium_mg_Grundmasse = Ammonium_mg; // mg/L bleibt mg/L
				var Ammonium_ergebnis = Ammonium_mg_Grundmasse + Ammonium_mol_Grundmasse;
			}
			else if (!isNaN(Ammonium_mg)) {
				var Ammonium_ergebnis = Ammonium_mg;
			}
			else if (!isNaN(Ammonium_mmol)) {
				var Ammonium_mol = Ammonium_mmol / 1000; // mmol/L in mol/L umrechnen
				var Ammonium_mg_Grundmasse = Ammonium_mol * 18038.46; // mol/L in mg/L umrechnen
				var Ammonium_ergebnis = Ammonium_mg_Grundmasse;
			}
			// Gibt das Ergebnis aus
			document.getElementById("Ammonium-ergebnis").innerHTML = Ammonium_ergebnis.toFixed(2) + " mg/L";

    // Phosphat Ergebnisse berechnen
			var Phosphat_mg = parseFloat(document.getElementById("Phosphat-mg").value);
			var Phosphat_mmol = parseFloat(document.getElementById("Phosphat-mmol").value);
			// Überprüft ob die Felder leer sind
			if (isNaN(Phosphat_mg) && isNaN(Phosphat_mmol)) {
				alert("Bitte in einem Eingabefeld von Phosphat den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Phosphat_mg) && !isNaN(Phosphat_mmol)) {
				var Phosphor_mol = Phosphat_mmol / 1000; // mmol/L in mol/L umrechnen
				var Phosphat_mol_Grundmasse = Phosphor_mol * 94971.4; // mol/L in mg/L umrechnen
				var Phosphat_mg_Grundmasse = Phosphat_mg; // mg/L bleibt mg/L
				var Phosphat_ergebnis = Phosphat_mg_Grundmasse + Phosphor_mol_Grundmasse;
			}
			else if (!isNaN(Phosphat_mg)) {
				var Phosphat_ergebnis = Phosphat_mg;
			}
			else if (!isNaN(Phosphat_mmol)) {
				var Phosphor_mol = Phosphat_mmol / 1000; // mmol/L in mol/L umrechnen
				var Phosphat_mg_Grundmasse = Phosphor_mol * 94971.4; // mol/L in mg/L umrechnen
				var Phosphat_ergebnis = Phosphat_mg_Grundmasse;
			}
			// Gibt das Ergebnis aus
			document.getElementById("Phosphat-ergebnis").innerHTML = Phosphat_ergebnis.toFixed(2) + " mg/L";

    // Kalium Ergebnisse berechnen
			var Kalium_mg = parseFloat(document.getElementById("Kalium-mg").value);
			var Kalium_mmol = parseFloat(document.getElementById("Kalium-mmol").value);
			// Überprüft ob die Felder leer sind
			if (isNaN(Kalium_mg) && isNaN(Kalium_mmol)) {
				alert("Bitte in einem Eingabefeld von Kalium den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Kalium_mg) && !isNaN(Kalium_mmol)) {
				var Kalium_mol = Kalium_mmol / 1000; // mmol/L in mol/L umrechnen
				var Kalium_mol_Grundmasse = Kalium_mol * 39098.30; // mol/L in mg/L umrechnen
				var Kalium_mg_Grundmasse = Kalium_mg; // mg/L bleibt mg/L
				var Kalium_ergebnis = Kalium_mg_Grundmasse + Kalium_mol_Grundmasse;
			}
			else if (!isNaN(Kalium_mg)) {
				var Kalium_ergebnis = Kalium_mg;
			}
			else if (!isNaN(Kalium_mmol)) {
				var Kalium_mol = Kalium_mmol / 1000; // mmol/L in mol/L umrechnen
				var Kalium_mg_Grundmasse = Kalium_mol * 39098.30; // mol/L in mg/L umrechnen
				var Kalium_ergebnis = Kalium_mg_Grundmasse;
			}
			// Gibt das Ergebnis aus
			document.getElementById("Kalium-ergebnis").innerHTML = Kalium_ergebnis.toFixed(2) + " mg/L";
    
    // Calcium Ergebnisse berechnen
			var Calcium_mg = parseFloat(document.getElementById("Calcium-mg").value);
			var Calcium_mmol = parseFloat(document.getElementById("Calcium-mmol").value);
			// Überprüft ob die Felder leer sind
			if (isNaN(Calcium_mg) && isNaN(Calcium_mmol)) {
				alert("Bitte in einem Eingabefeld von Calcium den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Calcium_mg) && !isNaN(Calcium_mmol)) {
				var Calcium_mol = Calcium_mmol / 1000; // mmol/L in mol/L umrechnen
				var Calcium_mol_Grundmasse = Calcium_mol * 40078.0; // mol/L in mg/L umrechnen
				var Calcium_mg_Grundmasse = Calcium_mg; // mg/L bleibt mg/L
				var Calcium_ergebnis = Calcium_mg_Grundmasse + Calcium_mol_Grundmasse;
			}
			else if (!isNaN(Calcium_mg)) {
				var Calcium_ergebnis = Calcium_mg;
			}
			else if (!isNaN(Calcium_mmol)) {
				var Calcium_mol = Calcium_mmol / 1000; // mmol/L in mol/L umrechnen
				var Calcium_mg_Grundmasse = Calcium_mol * 40078.0; // mol/L in mg/L umrechnen
				var Calcium_ergebnis = Calcium_mg_Grundmasse;
			}
			// Gibt das Ergebnis aus
			document.getElementById("Calcium-ergebnis").innerHTML = Calcium_ergebnis.toFixed(2) + " mg/L";

	// Magnesium Ergebnisse berechnen
			var Magnesium_mg = parseFloat(document.getElementById("Magnesium-mg").value);
			var Magnesium_mmol = parseFloat(document.getElementById("Magnesium-mmol").value);
			// Überprüft ob ein Feld leer ist
			if (isNaN(Magnesium_mg) && isNaN(Magnesium_mmol)) {
				alert("Bitte in einem Eingabefeld von Magnesium den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Magnesium_mg) && !isNaN(Magnesium_mmol)) {
				var Magnesium_mol = Magnesium_mmol / 1000; // mmol/L in mol/L umrechnen
				var Magnesium_mol_Grundmasse = Magnesium_mol * 24305.00; // mol/L in mg/L umrechnen
				var Magnesium_mg_Grundmasse = Magnesium_mg; // mg/L bleibt mg/L
				var Magnesium_ergebnis = Magnesium_mg_Grundmasse + Magnesium_mol_Grundmasse;
			}
			else if (!isNaN(Magnesium_mg)) {
				var Magnesium_ergebnis = Magnesium_mg;
			}
			else if (!isNaN(Magnesium_mmol)) {
				var Magnesium_mol = Magnesium_mmol / 1000; // mmol/L in mol/L umrechnen
				var Magnesium_mg_Grundmasse = Magnesium_mol * 24305.00; // mol/L in mg/L umrechnen
				var Magnesium_ergebnis = Magnesium_mg_Grundmasse;
			}
			// Geben Sie das Ergebnis aus
			document.getElementById("Magnesium-ergebnis").innerHTML = Magnesium_ergebnis.toFixed(2) + " mg/L";

    // Sulfat Ergebnisse berechnen
			var Sulfat_mg = parseFloat(document.getElementById("Sulfat-mg").value);
			var Sulfat_mmol = parseFloat(document.getElementById("Sulfat-mmol").value);
			// Überprüft ob die Felder leer sind
			if (isNaN(Sulfat_mg) && isNaN(Sulfat_mmol)) {
				alert("Bitte in einem Eingabefeld von Sulfat den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Sulfat_mg) && !isNaN(Sulfat_mmol)) {
				var Sulfat_mol = Sulfat_mmol / 1000; // mmol/L in mol/L umrechnen
				var Sulfat_mol_Grundmasse = Sulfat_mol * 96062.6; // mol/L in mg/L umrechnen
				var Sulfat_mg_Grundmasse = Sulfat_mg; // mg/L bleibt mg/L
				var Sulfat_ergebnis = Sulfat_mg_Grundmasse + Sulfat_mol_Grundmasse;
			}
			else if (!isNaN(Sulfat_mg)) {
				var Sulfat_ergebnis = Sulfat_mg;
			}
			else if (!isNaN(Sulfat_mmol)) {
				var Sulfat_mol = Sulfat_mmol / 1000; // mmol/L in mol/L umrechnen
				var Sulfat_mg_Grundmasse = Sulfat_mol * 96062.6; // mol/L in mg/L umrechnen
				var Sulfat_ergebnis = Sulfat_mg_Grundmasse;
			}
			// Gibt das Ergebnis aus
			document.getElementById("Sulfat-ergebnis").innerHTML = Sulfat_ergebnis.toFixed(2) + " mg/L";

    // Eisen Ergebnisse berechnen
			var Eisen_mg = parseFloat(document.getElementById("Eisen-mg").value);
			var Eisen_mmol = parseFloat(document.getElementById("Eisen-mmol").value);
			// Überprüft ob die Felder leer sind
			if (isNaN(Eisen_mg) && isNaN(Eisen_mmol)) {
				alert("Bitte in einem Eingabefeld von Eisen den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Eisen_mg) && !isNaN(Eisen_mmol)) {
				var Eisen_mol = Eisen_mmol / 1000; // mmol/L in mol/L umrechnen
				var Eisen_mol_Grundmasse = Eisen_mol * 55845.0; // mol/L in mg/L umrechnen
				var Eisen_mg_Grundmasse = Eisen_mg; // mg/L bleibt mg/L
				var Eisen_ergebnis = Eisen_mg_Grundmasse + Eisen_mol_Grundmasse;
			}
			else if (!isNaN(Eisen_mg)) {
				var Eisen_ergebnis = Eisen_mg;
			}
			else if (!isNaN(Eisen_mmol)) {
				var Eisen_mol = Eisen_mmol / 1000; // mmol/L in mol/L umrechnen
				var Eisen_mg_Grundmasse = Eisen_mol * 55845.0; // mol/L in mg/L umrechnen
				var Eisen_ergebnis = Eisen_mg_Grundmasse;
			}
			// Gibt das Ergebnis aus
			document.getElementById("Eisen-ergebnis").innerHTML = Eisen_ergebnis.toFixed(2) + " mg/L";  

    // Mangan Ergebnisse berechnen
			var Mangan_mg = parseFloat(document.getElementById("Mangan-mg").value);
			var Mangan_mmol = parseFloat(document.getElementById("Mangan-mmol").value);
			// Überprüft ob die Felder leer sind
			if (isNaN(Mangan_mg) && isNaN(Mangan_mmol)) {
				alert("Bitte in einem Eingabefeld von Mangan den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Mangan_mg) && !isNaN(Mangan_mmol)) {
				var Mangan_mol = Mangan_mmol / 1000; // mmol/L in mol/L umrechnen
				var Mangan_mol_Grundmasse = Mangan_mol * 54938.0450; // mol/L in mg/L umrechnen
				var Mangan_mg_Grundmasse = Mangan_mg; // mg/L bleibt mg/L
				var Mangan_ergebnis = Mangan_mg_Grundmasse + Mangan_mol_Grundmasse;
			}
			else if (!isNaN(Mangan_mg)) {
				var Mangan_ergebnis = Mangan_mg;
			}
			else if (!isNaN(Mangan_mmol)) {
				var Mangan_mol = Mangan_mmol / 1000; // mmol/L in mol/L umrechnen
				var Mangan_mg_Grundmasse = Mangan_mol * 54938.0450; // mol/L in mg/L umrechnen
				var Mangan_ergebnis = Mangan_mg_Grundmasse;
			}
			// Gibt das Ergebnis aus
			document.getElementById("Mangan-ergebnis").innerHTML = Mangan_ergebnis.toFixed(2) + " mg/L";

    // Zink Ergebnisse berechnen
			var Zink_mg = parseFloat(document.getElementById("Zink-mg").value);
			var Zink_mmol = parseFloat(document.getElementById("Zink-mmol").value);
			// Überprüft ob die Felder leer sind
			if (isNaN(Zink_mg) && isNaN(Zink_mmol)) {
				alert("Bitte in einem Eingabefeld von Zink den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Zink_mg) && !isNaN(Zink_mmol)) {
				var Zink_mol = Zink_mmol / 1000; // mmol/L in mol/L umrechnen
				var Zink_mol_Grundmasse = Zink_mol * 65380.0; // mol/L in mg/L umrechnen
				var Zink_mg_Grundmasse = Zink_mg; // mg/L bleibt mg/L
				var Zink_ergebnis = Zink_mg_Grundmasse + Zink_mol_Grundmasse;
			}
			else if (!isNaN(Zink_mg)) {
				var Zink_ergebnis = Zink_mg;
			}
			else if (!isNaN(Zink_mmol)) {
				var Zink_mol = Zink_mmol / 1000; // mmol/L in mol/L umrechnen
				var Zink_mg_Grundmasse = Zink_mol * 65380.0; // mol/L in mg/L umrechnen
				var Zink_ergebnis = Zink_mg_Grundmasse;
			}
			// Gibt das Ergebnis aus
			document.getElementById("Zink-ergebnis").innerHTML = Zink_ergebnis.toFixed(2) + " mg/L";

    // Kupfer Ergebnisse berechnen
			var Kupfer_mg = parseFloat(document.getElementById("Kupfer-mg").value);
			var Kupfer_mmol = parseFloat(document.getElementById("Kupfer-mmol").value);
			// Überprüft ob die Felder leer sind
			if (isNaN(Kupfer_mg) && isNaN(Kupfer_mmol)) {
				alert("Bitte in einem Eingabefeld von Kupfer den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Kupfer_mg) && !isNaN(Kupfer_mmol)) {
				var Kupfer_mol = Kupfer_mmol / 1000; // mmol/L in mol/L umrechnen
				var Kupfer_mol_Grundmasse = Kupfer_mol * 63546.0; // mol/L in mg/L umrechnen
				var Kupfer_mg_Grundmasse = Kupfer_mg; // mg/L bleibt mg/L
				var Kupfer_ergebnis = Kupfer_mg_Grundmasse + Kupfer_mol_Grundmasse;
			}
			else if (!isNaN(Kupfer_mg)) {
				var Kupfer_ergebnis = Kupfer_mg;
			}
			else if (!isNaN(Kupfer_mmol)) {
				var Kupfer_mol = Kupfer_mmol / 1000; // mmol/L in mol/L umrechnen
				var Kupfer_mg_Grundmasse = Kupfer_mol * 63546.0; // mol/L in mg/L umrechnen
				var Kupfer_ergebnis = Kupfer_mg_Grundmasse;
			}
			// Gibt das Ergebnis aus
			document.getElementById("Kupfer-ergebnis").innerHTML = Kupfer_ergebnis.toFixed(2) + " mg/L";

    // Molybdän Ergebnisse berechnen
			var Molybdän_mg = parseFloat(document.getElementById("Molybdän-mg").value);
			var Molybdän_mmol = parseFloat(document.getElementById("Molybdän-mmol").value);
			// Überprüft ob die Felder leer sind
			if (isNaN(Molybdän_mg) && isNaN(Molybdän_mmol)) {
				alert("Bitte in einem Eingabefeld von Molybdän den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Molybdän_mg) && !isNaN(Molybdän_mmol)) {
				var Molybdän_mol = Molybdän_mmol / 1000; // mmol/L in mol/L umrechnen
				var Molybdän_mol_Grundmasse = Molybdän_mol * 95960.0; // mol/L in mg/L umrechnen
				var Molybdän_mg_Grundmasse = Molybdän_mg; // mg/L bleibt mg/L
				var Molybdän_ergebnis = Molybdän_mg_Grundmasse + Molybdän_mol_Grundmasse;
			}
			else if (!isNaN(Molybdän_mg)) {
				var Molybdän_ergebnis = Molybdän_mg;
			}
			else if (!isNaN(Molybdän_mmol)) {
				var Molybdän_mol = Molybdän_mmol / 1000; // mmol/L in mol/L umrechnen
				var Molybdän_mg_Grundmasse = Molybdän_mol * 95960.0; // mol/L in mg/L umrechnen
				var Molybdän_ergebnis = Molybdän_mg_Grundmasse;
			}
			// Gibt das Ergebnis aus
			document.getElementById("Molybdän-ergebnis").innerHTML = Molybdän_ergebnis.toFixed(2) + " mg/L";

    // Bor Ergebnisse berechnen
			var Bor_mg = parseFloat(document.getElementById("Bor-mg").value);
			var Bor_mmol = parseFloat(document.getElementById("Bor-mmol").value);
			// Überprüft ob die Felder leer sind
			if (isNaN(Bor_mg) && isNaN(Bor_mmol)) {
				alert("Bitte in einem Eingabefeld von Bor den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Bor_mg) && !isNaN(Bor_mmol)) {
				var Bor_mol = Bor_mmol / 1000; // mmol/L in mol/L umrechnen
				var Bor_mol_Grundmasse = Bor_mol * 10811.0; // mol/L in mg/L umrechnen
				var Bor_mg_Grundmasse = Bor_mg; // mg/L bleibt mg/L
				var Bor_ergebnis = Bor_mg_Grundmasse + Bor_mol_Grundmasse;
			}
			else if (!isNaN(Bor_mg)) {
				var Bor_ergebnis = Bor_mg;
			}
			else if (!isNaN(Bor_mmol)) {
				var Bor_mol = Bor_mmol / 1000; // mmol/L in mol/L umrechnen
				var Bor_mg_Grundmasse = Bor_mol * 10811.0; // mol/L in mg/L umrechnen
				var Bor_ergebnis = Bor_mg_Grundmasse;
			}
			// Gibt das Ergebnis aus
			document.getElementById("Bor-ergebnis").innerHTML = Bor_ergebnis.toFixed(2) + " mg/L";

    // Chlorid Ergebnisse berechnen
			var Chlorid_mg = parseFloat(document.getElementById("Chlorid-mg").value);
			var Chlorid_mmol = parseFloat(document.getElementById("Chlorid-mmol").value);
			// Überprüft ob die Felder leer sind
			if (isNaN(Chlorid_mg) && isNaN(Chlorid_mmol)) {
				alert("Bitte in einem Eingabefeld von Chlorid den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Chlorid_mg) && !isNaN(Chlorid_mmol)) {
				var Chlorid_mol = Chlorid_mmol / 1000; // mmol/L in mol/L umrechnen
				var Chlorid_mol_Grundmasse = Chlorid_mol * 35453.0; // mol/L in mg/L umrechnen
				var Chlorid_mg_Grundmasse = Chlorid_mg; // mg/L bleibt mg/L
				var Chlorid_ergebnis = Chlorid_mg_Grundmasse + Chlorid_mol_Grundmasse;
			}
			else if (!isNaN(Chlorid_mg)) {
				var Chlorid_ergebnis = Chlorid_mg;
			}
			else if (!isNaN(Chlorid_mmol)) {
				var Chlorid_mol = Chlorid_mmol / 1000; // mmol/L in mol/L umrechnen
				var Chlorid_mg_Grundmasse = Chlorid_mol * 35453.0; // mol/L in mg/L umrechnen
				var Chlorid_ergebnis = Chlorid_mg_Grundmasse;
			}
			// Gibt das Ergebnis aus
			document.getElementById("Chlorid-ergebnis").innerHTML = Chlorid_ergebnis.toFixed(2) + " mg/L";

    // Nickel Ergebnisse berechnen
			var Nickel_mg = parseFloat(document.getElementById("Nickel-mg").value);
			var Nickel_mmol = parseFloat(document.getElementById("Nickel-mmol").value);
			// Überprüft ob die Felder leer sind
			if (isNaN(Nickel_mg) && isNaN(Nickel_mmol)) {
				alert("Bitte in einem Eingabefeld von Nickel den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Nickel_mg) && !isNaN(Nickel_mmol)) {
				var Nickel_mol = Nickel_mmol / 1000; // mmol/L in mol/L umrechnen
				var Nickel_mol_Grundmasse = Nickel_mol * 58693.40; // mol/L in mg/L umrechnen
				var Nickel_mg_Grundmasse = Nickel_mg; // mg/L bleibt mg/L
				var Nickel_ergebnis = Nickel_mg_Grundmasse + Nickel_mol_Grundmasse;
			}
			else if (!isNaN(Nickel_mg)) {
				var Nickel_ergebnis = Nickel_mg;
			}
			else if (!isNaN(Nickel_mmol)) {
				var Nickel_mol = Nickel_mmol / 1000; // mmol/L in mol/L umrechnen
				var Nickel_mg_Grundmasse = Nickel_mol * 58693.40; // mol/L in mg/L umrechnen
				var Nickel_ergebnis = Nickel_mg_Grundmasse;
			}
			// Gibt das Ergebnis aus
			document.getElementById("Nickel-ergebnis").innerHTML = Nickel_ergebnis.toFixed(2) + " mg/L";

    // Cobalt Ergebnisse berechnen
			var Cobalt_mg = parseFloat(document.getElementById("Cobalt-mg").value);
			var Cobalt_mmol = parseFloat(document.getElementById("Cobalt-mmol").value);
			// Überprüft ob die Felder leer sind
			if (isNaN(Cobalt_mg) && isNaN(Cobalt_mmol)) {
				alert("Bitte in einem Eingabefeld von Cobalt den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Cobalt_mg) && !isNaN(Cobalt_mmol)) {
				var Cobalt_mol = Cobalt_mmol / 1000; // mmol/L in mol/L umrechnen
				var Cobalt_mol_Grundmasse = Cobalt_mol * 58933.1950; // mol/L in mg/L umrechnen
				var Cobalt_mg_Grundmasse = Cobalt_mg; // mg/L bleibt mg/L
				var Cobalt_ergebnis = Cobalt_mg_Grundmasse + Cobalt_mol_Grundmasse;
			}
			else if (!isNaN(Cobalt_mg)) {
				var Cobalt_ergebnis = Cobalt_mg;
			}
			else if (!isNaN(Cobalt_mmol)) {
				var Cobalt_mol = Cobalt_mmol / 1000; // mmol/L in mol/L umrechnen
				var Cobalt_mg_Grundmasse = Cobalt_mol * 58933.1950; // mol/L in mg/L umrechnen
				var Cobalt_ergebnis = Cobalt_mg_Grundmasse;
			}
			// Gibt das Ergebnis aus
			document.getElementById("Cobalt-ergebnis").innerHTML = Cobalt_ergebnis.toFixed(2) + " mg/L";

    // Natrium Ergebnisse berechnen
			var Natrium_mg = parseFloat(document.getElementById("Natrium-mg").value);
			var Natrium_mmol = parseFloat(document.getElementById("Natrium-mmol").value);
			// Überprüft ob die Felder leer sind
			if (isNaN(Natrium_mg) && isNaN(Natrium_mmol)) {
				alert("Bitte in einem Eingabefeld von Natrium den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Natrium_mg) && !isNaN(Natrium_mmol)) {
				var Natrium_mol = Natrium_mmol / 1000; // mmol/L in mol/L umrechnen
				var Natrium_mol_Grundmasse = Natrium_mol * 22989.769280; // mol/L in mg/L umrechnen
				var Natrium_mg_Grundmasse = Natrium_mg; // mg/L bleibt mg/L
				var Natrium_ergebnis = Natrium_mg_Grundmasse + Natrium_mol_Grundmasse;
			}
			else if (!isNaN(Natrium_mg)) {
				var Natrium_ergebnis = Natrium_mg;
			}
			else if (!isNaN(Natrium_mmol)) {
				var Natrium_mol = Natrium_mmol / 1000; // mmol/L in mol/L umrechnen
				var Natrium_mg_Grundmasse = Natrium_mol * 22989.769280; // mol/L in mg/L umrechnen
				var Natrium_ergebnis = Natrium_mg_Grundmasse;
			}
			// Gibt das Ergebnis aus
			document.getElementById("Natrium-ergebnis").innerHTML = Natrium_ergebnis.toFixed(2) + " mg/L";

    // Aluminium Ergebnisse berechnen
			var Aluminium_mg = parseFloat(document.getElementById("Aluminium-mg").value);
			var Aluminium_mmol = parseFloat(document.getElementById("Aluminium-mmol").value);
			// Überprüft ob die Felder leer sind
			if (isNaN(Aluminium_mg) && isNaN(Aluminium_mmol)) {
				alert("Bitte in einem Eingabefeld von Aluminium den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Aluminium_mg) && !isNaN(Aluminium_mmol)) {
				var Aluminium_mol = Aluminium_mmol / 1000; // mmol/L in mol/L umrechnen
				var Aluminium_mol_Grundmasse = Aluminium_mol * 26981.53860; // mol/L in mg/L umrechnen
				var Aluminium_mg_Grundmasse = Aluminium_mg; // mg/L bleibt mg/L
				var Aluminium_ergebnis = Aluminium_mg_Grundmasse + Aluminium_mol_Grundmasse;
			}
			else if (!isNaN(Aluminium_mg)) {
				var Aluminium_ergebnis = Aluminium_mg;
			}
			else if (!isNaN(Aluminium_mmol)) {
				var Aluminium_mol = Aluminium_mmol / 1000; // mmol/L in mol/L umrechnen
				var Aluminium_mg_Grundmasse = Aluminium_mol * 26981.53860; // mol/L in mg/L umrechnen
				var Aluminium_ergebnis = Aluminium_mg_Grundmasse;
			}
			// Gibt das Ergebnis aus
			document.getElementById("Aluminium-ergebnis").innerHTML = Aluminium_ergebnis.toFixed(2) + " mg/L";

    // Silizium Ergebnisse berechnen
			var Silizium_mg = parseFloat(document.getElementById("Silizium-mg").value);
			var Silizium_mmol = parseFloat(document.getElementById("Silizium-mmol").value);
			// Überprüft ob die Felder leer sind
			if (isNaN(Silizium_mg) && isNaN(Silizium_mmol)) {
				alert("Bitte in einem Eingabefeld von Silizium den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Silizium_mg) && !isNaN(Silizium_mmol)) {
				var Silizium_mol = Silizium_mmol / 1000; // mmol/L in mol/L umrechnen
				var Silizium_mol_Grundmasse = Silizium_mol * 60084.30; // mol/L in mg/L umrechnen
				var Silizium_mg_Grundmasse = Silizium_mg; // mg/L bleibt mg/L
				var Silizium_ergebnis = Silizium_mg_Grundmasse + Silizium_mol_Grundmasse;
			}
			else if (!isNaN(Silizium_mg)) {
				var Silizium_ergebnis = Silizium_mg;
			}
			else if (!isNaN(Silizium_mmol)) {
				var Silizium_mol = Silizium_mmol / 1000; // mmol/L in mol/L umrechnen
				var Silizium_mg_Grundmasse = Silizium_mol * 60084.30; // mol/L in mg/L umrechnen
				var Silizium_ergebnis = Silizium_mg_Grundmasse;
			}
			// Gibt das Ergebnis aus
			document.getElementById("Silizium-ergebnis").innerHTML = Silizium_ergebnis.toFixed(2) + " mg/L";

	// Calciumcarbonat Ergebnisse berechnen
			var CaCarbo_mg = parseFloat(document.getElementById("CaCarbo-mg").value);
			var CaCarbo_mmol = parseFloat(document.getElementById("CaCarbo-mmol").value);
			// Überprüft ob ein Feld leer ist
			if (isNaN(CaCarbo_mg) && isNaN(CaCarbo_mmol)) {
				alert("Bitte in einem Eingabefeld von Calciumkarbonat den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(CaCarbo_mg) && !isNaN(CaCarbo_mmol)) {
				var CaCarbo_mol = CaCarbo_mmol / 1000; // mmol/L in mol/L umrechnen
				var CaCarbo_mol_Grundmasse = CaCarbo_mol * 100086.9; // mol/L in mg/L umrechnen
				var CaCarbo_mg_Grundmasse = CaCarbo_mg; // mg/L bleibt mg/L
				var CaCarbo_HCO = CaCarbo_mg_Grundmasse + CaCarbo_mol_Grundmasse;
				var CaCarbo_ergebnis = CaCarbo_HCO * 0.5;
				var CaCarboKH_ergebnis = CaCarbo_ergebnis / 21.8;
			}
			else if (!isNaN(CaCarbo_mg)) {
				var CaCarbo_ergebnis = CaCarbo_mg * 0.5;
				var CaCarboKH_ergebnis = CaCarbo_ergebnis / 21.8;
			}
			else if (!isNaN(CaCarbo_mmol)) {
				var CaCarbo_mol = CaCarbo_mmol / 1000; // mmol/L in mol/L umrechnen
				var CaCarbo_mg_Grundmasse = CaCarbo_mol * 100086.9; // mol/L in mg/L umrechnen
				var CaCarbo_ergebnis = CaCarbo_mg_Grundmasse * 0.5;
				var CaCarboKH_ergebnis = CaCarbo_ergebnis / 21.8;
			}
			// Geben Sie das Ergebnis aus
			document.getElementById("CaCarbo-ergebnis").innerHTML = CaCarbo_ergebnis.toFixed(2) + " mg/L";
			document.getElementById("CaCarboKH-ergebnis").innerHTML = CaCarboKH_ergebnis.toFixed(2) + " dH°";

    // Hydrocarbonate Ergebnisse berechnen
			var Hydrocarbo_mg = parseFloat(document.getElementById("Hydrocarbo-mg").value);
			var Hydrocarbo_mmol = parseFloat(document.getElementById("Hydrocarbo-mmol").value);
			// Überprüft ob die Felder leer sind
			if (isNaN(Hydrocarbo_mg) && isNaN(Hydrocarbo_mmol)) {
				alert("Bitte in einem Eingabefeld von Hydrokarbonaten HCO3 den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Hydrocarbo_mg) && !isNaN(Hydrocarbo_mmol)) {
				var Hydrocarbo_mol = Hydrocarbo_mmol / 1000; // mmol/L in mol/L umrechnen
				var Hydrocarbo_mol_Grundmasse = Hydrocarbo_mol * 61016.8; // mol/L in mg/L umrechnen
				var Hydrocarbo_mg_Grundmasse = Hydrocarbo_mg; // mg/L bleibt mg/L
				var Hydrocarbo_ergebnis = Hydrocarbo_mg_Grundmasse + Hydrocarbo_mol_Grundmasse;
				var Hydrocarbo_dH_ergebnis = Hydrocarbo_ergebnis / 21.8;
			}
			else if (!isNaN(Hydrocarbo_mg)) {
				var Hydrocarbo_ergebnis = Hydrocarbo_mg;
				var Hydrocarbo_dH_ergebnis = Hydrocarbo_ergebnis / 21.8;
				
			}
			else if (!isNaN(Hydrocarbo_mmol)) {
				var Hydrocarbo_mol = Hydrocarbo_mmol / 1000; // mmol/L in mol/L umrechnen
				var Hydrocarbo_mg_Grundmasse = Hydrocarbo_mol * 61016.8; // mol/L in mg/L umrechnen
				var Hydrocarbo_ergebnis = Hydrocarbo_mg_Grundmasse;
				var Hydrocarbo_dH_ergebnis = Hydrocarbo_ergebnis / 21.8;
			}
			// Gibt das Ergebnis aus
			document.getElementById("Hydrocarbo-ergebnis").innerHTML = Hydrocarbo_ergebnis.toFixed(2) + " mg/L";
			document.getElementById("Hydrocarbo-dH-ergebnis").innerHTML = Hydrocarbo_dH_ergebnis.toFixed(2) + " dH°";

    // Säure-Base Kapazität Ergebnisse berechnen
			var SBK_mmol = parseFloat(document.getElementById("SBK-mmol").value);
			// Überprüft ob das Feld leer ist
			if (isNaN(SBK_mmol)) {
				alert("Bitte im Eingabefeld von Säure-Base Kapazität den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(SBK_mmol)) {
				var SBK_KH_ergebnis = SBK_mmol / 0.357; // mmol/L in dH umrechnen
				var SBK_ergebnis = SBK_KH_ergebnis * 21.8; // dH in mg/L umrechnen
			
			}
			// Gibt das Ergebnis aus
			document.getElementById("SBK-ergebnis").innerHTML = SBK_ergebnis.toFixed(2) + " mg/L";
      		document.getElementById("SBK-KH-ergebnis").innerHTML = SBK_KH_ergebnis.toFixed(2) + " dH°";

    // Karbonathärte Ergebnisse berechnen
			var Karbo_dH = parseFloat(document.getElementById("Karbo-dH").value);
			// Überprüft ob das Feld leer ist
			if (isNaN(Karbo_dH)) {
				alert("Bitte im Eingabefeld der Karbonathärte den Mindestwert 0 eintragen.");
				return;
			}
			// Berechnet das Ergebnis entsprechend
			if (!isNaN(Karbo_dH)) {
				var Karbo_ergebnis = Karbo_dH * 21.8; // dH in mg/L umrechnen
			
			}
			// Gibt das Ergebnis aus
			document.getElementById("Karbo-ergebnis").innerHTML = Karbo_ergebnis.toFixed(2) + " mg/L";
		
	
	//Eine Konstante für alle Kationen festlegen
			const ammonium = document.getElementById("Ammonium-ergebnis");
			const kalium = document.getElementById("Kalium-ergebnis");
			const calcium = document.getElementById("Calcium-ergebnis");
			const magnesium = document.getElementById("Magnesium-ergebnis");
			const eisen = document.getElementById("Eisen-ergebnis");
			const mangan = document.getElementById("Mangan-ergebnis");
			const zink = document.getElementById("Zink-ergebnis");
			const kupfer = document.getElementById("Kupfer-ergebnis");
			const nickel = document.getElementById("Nickel-ergebnis");
			const cobalt = document.getElementById("Cobalt-ergebnis");
			const natrium = document.getElementById("Natrium-ergebnis");
			const aluminium = document.getElementById("Aluminium-ergebnis");
			

			// Extrahiere die Werte aus den Elementen
			const Kat_Ammonium_mg = parseFloat(ammonium.innerHTML);
			const Kat_Kalium_mg = parseFloat(kalium.innerHTML);
			const Kat_Calcium_mg = parseFloat(calcium.innerHTML);
			const Kat_Magnesium_mg = parseFloat(magnesium.innerHTML);
			const Kat_Eisen_mg = parseFloat(eisen.innerHTML);
			const Kat_Mangan_mg = parseFloat(mangan.innerHTML);
			const Kat_Zink_mg = parseFloat(zink.innerHTML);
			const Kat_Kupfer_mg = parseFloat(kupfer.innerHTML);
			const Kat_Nickel_mg = parseFloat(nickel.innerHTML);
			const Kat_Cobalt_mg = parseFloat(cobalt.innerHTML);
			const Kat_Natrium_mg = parseFloat(natrium.innerHTML);
			const Kat_Aluminium_mg = parseFloat(aluminium.innerHTML);

	// Berechne die Ergebnisse der Kationen
			const Kat_Makro_ergebnis = Kat_Ammonium_mg + Kat_Kalium_mg + Kat_Calcium_mg + Kat_Magnesium_mg;
			const Kat_Mikro_ergebnis = Kat_Eisen_mg + Kat_Mangan_mg + Kat_Zink_mg + Kat_Kupfer_mg + Kat_Nickel_mg + Kat_Cobalt_mg;
			const Kat_Hilf_ergebnis = Kat_Aluminium_mg + Kat_Natrium_mg;
			const Kat_Ges_ergebnis = Kat_Makro_ergebnis + Kat_Mikro_ergebnis + Kat_Hilf_ergebnis;

			// Gib das Ergebnis aus
			document.getElementById("KatGes-ergebnis").innerHTML = Kat_Ges_ergebnis.toFixed(2) + " mg/L";

	//Eine Konstante für alle Anionen festlegen
			const nitrat = document.getElementById("Nitrat-ergebnis");
			const phosphat = document.getElementById("Phosphat-ergebnis");
			const sulfat = document.getElementById("Sulfat-ergebnis");
			const molybdän = document.getElementById("Molybdän-ergebnis");
			const bor = document.getElementById("Bor-ergebnis");
			const chlorid = document.getElementById("Chlorid-ergebnis");
			const silizium = document.getElementById("Silizium-ergebnis");
			const cacarbo = document.getElementById("CaCarbo-ergebnis");
			const hydrocarbo = document.getElementById("Hydrocarbo-ergebnis");
			const sbk = document.getElementById("SBK-ergebnis");
			const karbo = document.getElementById("Karbo-ergebnis");
			

			// Extrahiere die Werte aus den Elementen
			const Ani_Nitrat_mg = parseFloat(nitrat.innerHTML);
			const Ani_Phosphat_mg = parseFloat(phosphat.innerHTML);
			const Ani_Sulfat_mg = parseFloat(sulfat.innerHTML);
			const Ani_Molybdän_mg = parseFloat(molybdän.innerHTML);
			const Ani_Bor_mg = parseFloat(bor.innerHTML);
			const Ani_Chlorid_mg = parseFloat(chlorid.innerHTML);
			const Ani_Silizium_mg = parseFloat(silizium.innerHTML);
			
			// Funktion für das ermitteln des größten Wertes
			function findMax() {
			const Ani_CaCarbo_mg = parseInt(cacarbo.innerHTML);
			const Ani_HydroCarbo_mg = parseInt(hydrocarbo.innerHTML);
			const Ani_SBK_mg = parseInt(sbk.innerHTML);
			const Ani_Karbo_mg = parseInt(karbo.innerHTML);
			return Math.max(Ani_CaCarbo_mg, Ani_HydroCarbo_mg, Ani_SBK_mg, Ani_Karbo_mg); 		
			}
			// Die größte Zahl aus den Karbonaten finden
			const max = findMax();

	// Berechne die Ergebnisse der Anionen
			const Ani_Makro_ergebnis = Ani_Nitrat_mg + Ani_Phosphat_mg + Ani_Sulfat_mg;
			const Ani_Mikro_ergebnis = Ani_Molybdän_mg + Ani_Bor_mg + Ani_Chlorid_mg;
			const Ani_Hilf_ergebnis = Ani_Silizium_mg;
			const Ani_Karbo_ergebnis = max;
			const Ani_Ges_ergebnis = Ani_Makro_ergebnis + Ani_Mikro_ergebnis + Ani_Hilf_ergebnis + Ani_Karbo_ergebnis;

			// Gib das Ergebnis aus
			document.getElementById("AniGes-ergebnis").innerHTML = Ani_Ges_ergebnis.toFixed(2) + " mg/L";

	// Berechne das Anion zu Kation Verhältnis
			const AniKatVer_ergebnis = Ani_Ges_ergebnis / Kat_Ges_ergebnis;

			// Gib das Ergebnis aus
			document.getElementById("AniKatVer-ergebnis").innerHTML = AniKatVer_ergebnis.toFixed(2);


	// Berechne die Gesamthärte anteilig aus Calcium und Magnesium
			const CalciumDh_ergebnis = Kat_Calcium_mg / 7.14;
			const MagnesiumDh_ergebnis = Kat_Magnesium_mg / 4.33;
			const CaMgDh_ergebnis = CalciumDh_ergebnis + MagnesiumDh_ergebnis;

			// Gib das Ergebnis aus
			document.getElementById("GesHärte-ergebnis").innerHTML = CaMgDh_ergebnis.toFixed(2) + " dH°";

	// Leitwertberechnung der einzelnen Stoffe
			// Stoffmengenkonzentration ermitteln
			const Nitrat_smk = Ani_Nitrat_mg / 62.0049;
			const Ammonium_smk = Kat_Ammonium_mg / 18.03846;
			const Phosphat_smk = Ani_Phosphat_mg / 94.9714;
			const Kalium_smk = Kat_Kalium_mg / 39.09830;
			const Calcium_smk = Kat_Calcium_mg / 40.0780;
			const Magnesium_smk = Kat_Magnesium_mg / 24.30500;
			const Sulfat_smk = Ani_Sulfat_mg / 96.0626;
			const Eisen_smk = Kat_Eisen_mg / 55.8450;
			const Mangan_smk = Kat_Mangan_mg / 54.9380450;
			const Zink_smk = Kat_Zink_mg / 65.3800;
			const Kupfer_smk = Kat_Kupfer_mg / 63.5460;
			const Molybdän_smk = Ani_Molybdän_mg / 95.9600;
			const Bor_smk = Ani_Bor_mg / 10.8110;
			const Chlorid_smk = Ani_Chlorid_mg / 35.4530;
			const Nickel_smk = Kat_Nickel_mg / 58.69340;
			const Cobalt_smk = Kat_Cobalt_mg / 58.9331950;
			const Natrium_smk = Kat_Natrium_mg / 22.989769280;
			const Aluminium_smk = Kat_Aluminium_mg / 26.98153860;
			const Silizium_smk = Ani_Silizium_mg / 60.08430;
			const Hydrocarbo_smk = Ani_Karbo_ergebnis / 61.0168;

			// Achtet beim übernehmen des Code darauf, das hier dann noch einen Zwischenschritt
			// durch die Anzahl der Liter nehmen müsst, da aber alle Eingaben auf 1L Wasser beruhen,
			// müssen wir das hier nicht!

			// Einige Stoffe müssen in eine andere Form umgerechnen werden, 
			// damit sie vom Leitwert her berechnet werden können.
			const Molybdän_MoO4 = Molybdän_smk * 1.667;
			const Bor_H3BO3 = Bor_smk * 5.7;
			const Nickel_NiSO4 = Nickel_smk * 2.63;
			
			// Äquivalente Stoffmengenkonzentration anhand der Ladungzahl berechnen
			const Nitrat_aqui = Nitrat_smk * 1;
			const Ammonium_aqui = Ammonium_smk * 1;
			const Phosphat_aqui = Phosphat_smk * 3;
			const Kalium_aqui = Kalium_smk * 1;
			const Calcium_aqui = Calcium_smk * 2;
			const Magnesium_aqui = Magnesium_smk * 2;
			const Sulfat_aqui = Sulfat_smk * 2;
			const Eisen_aqui = Eisen_smk * 2;
			const Mangan_aqui = Mangan_smk * 2;
			const Zink_aqui = Zink_smk * 2;
			const Kupfer_aqui = Kupfer_smk * 2;
			const Molybdän_aqui = Molybdän_MoO4 * 2;
			const Bor_aqui = Bor_H3BO3 * 1;
			const Chlorid_aqui = Chlorid_smk *1;
			const Nickel_aqui = Nickel_NiSO4 * 2; 
			const Cobalt_aqui = Cobalt_smk * 2;
			const Natrium_aqui = Natrium_smk * 1;
			const Aluminium_aqui = Aluminium_smk * 3;
			const Silizium_aqui = Silizium_smk * 1;
			const Hydrocarbo_aqui = Hydrocarbo_smk * 1;

			// Temperturleit bei (//18 &) 25 Grad Celsius unter Vorbehalt ihrer Äquivalent-Grenzleitfähigkeit Scm2/mol Angaben
			//const Nitrat_temp1 = Nitrat_aqui * 71.4;
			const Nitrat_temp2 = Nitrat_aqui * 71.4;
			//const Ammoinim_temp1 = Ammonium_aqui * 74.6;
			const Ammonium_temp2 = Ammonium_aqui * 74.6;
			//const Phosphat_temp1 = Phosphat_aqui * 51.2;
			const Phosphat_temp2 = Phosphat_aqui * 51.2;
			//const Kalium_temp1 = Kalium_aqui * 73.5;
			const Kalium_temp2 = Kalium_aqui * 73.5;
			//const Calcium_temp1 = Calcium_aqui * 59.5;
			const Calcium_temp2 = Calcium_aqui * 59.5;
			//const Magnesium_temp1 = Magnesium_aqui * 53.4;
			const Magnesium_temp2 = Magnesium_aqui * 53.4;
			//const Sulfat_temp1 = Sulfat_aqui * 80.3;
			const Sulfat_temp2 = Sulfat_aqui * 80.3;
			//const Eisen_temp1 = Eisen_aqui * 56;
			const Eisen_temp2 = Eisen_aqui * 56;
			//const Mangan_temp1 = Mangan_aqui * 52.7;
			const Mangan_temp2 = Mangan_aqui * 53.7;
			//const Zink_temp1 = Zink_aqui * 41;
			const Zink_temp2 = Zink_aqui * 53.7;
			//const Kupfer_temp1 = Kupfer_aqui * 59.6;
			const Kupfer_temp2 = Kupfer_aqui * 59.6;
			//const Molybdän_temp1 = Molybdän_aqui * 149;
			const Molybdän_temp2 = Molybdän_aqui * 155;
			//const Bor_temp1 = Bor_aqui * 61.8; // H3BO4 Frag hierzu GPT nochmal selbst
			const Bor_temp2 = Bor_aqui * 61.8; // H3BO4 Frag hierzu GPT nochmal selbst
			//const Chlorid_temp1 = Chlorid_aqui * 76.3;
			const Chlorid_temp2 = Chlorid_aqui * 76.3;
			//const Nickel_temp1 = Nickel_aqui * 55.2; // NiSO4 Frag hierzu GPT nochmal selbst
			const Nickel_temp2 = Nickel_aqui * 61.2; // NiSO4 Frag hierzu GPT nochmal selbst
			//const Cobalt_temp1 = Cobalt_aqui * 55;
			const Cobalt_temp2 = Cobalt_aqui * 58.8;
			//const Natrium_temp1 = Natrium_aqui * 50.1;
			const Natrium_temp2 = Natrium_aqui * 50.1;
			//const Aluminium_temp1 = Aluminium_aqui * 63;
			const Aluminium_temp2 = Aluminium_aqui * 63;
			//const Silizium_temp1 = Silizium_aqui * 4.6; // Fragt hierzu GPT nochmal selbst
			const Silizium_temp2 = Silizium_aqui * 4.6; //Fragt hierzu GPT nochmal selbst
			//const Hydrocarbo_temp1 = Hydrocarbo_aqui * 44.5;
			const Hydrocarbo_temp2 = Hydrocarbo_aqui * 52.5;

			// Alle Leitwerte der Kationen in ys/cm bei 25 Grad Celsius berechnen
			const LeitwertKatMakro_ergebnis = Ammonium_temp2 + Kalium_temp2 + Calcium_temp2 + Magnesium_temp2;
			const LeitwertKatMikro_ergebnis = Eisen_temp2 + Mangan_temp2 + Zink_temp2 + Kupfer_temp2 + Cobalt_temp2;
			const LeitwertKatHilfs_ergebnis = Natrium_temp2 + Aluminium_temp2;
			const LeitwertKatiGesamt_ergebnis = LeitwertKatMakro_ergebnis + LeitwertKatMikro_ergebnis + LeitwertKatHilfs_ergebnis;

			// Alle Leitwerte der Anionen in ys/cm bei 25 Grad Celsius berechnen
			const LeitwertAniMakro_ergebnis = Nitrat_temp2 + Phosphat_temp2 + Sulfat_temp2;
			const LeitwertAniMikro_ergebnis = Molybdän_temp2 + Bor_temp2 + Nickel_temp2;
			const LeitwertAniHilfs_ergebnis = Silizium_temp2;
			const LeitwertAniKarbo_ergebnis = Hydrocarbo_temp2;
			const LeitwertAniGesamt_ergebnis = LeitwertAniMakro_ergebnis + LeitwertAniMikro_ergebnis + LeitwertKatHilfs_ergebnis + LeitwertAniKarbo_ergebnis;
			
			// Alle Leitwerte aus Kation und Anion berechnen
			const LeitwertGesamt_ergebnis = LeitwertKatiGesamt_ergebnis + LeitwertAniGesamt_ergebnis;

			// Gib das Ergebnis aus
			document.getElementById("Leitwert-ergebnis").innerHTML = LeitwertGesamt_ergebnis.toFixed(2) + " mS/cm";


		}
		

		function downloadCSV() {
    		// Hier wird der Wert der Ergebnisse extrahiert
  			const nitratErgebnis = document.getElementById("Nitrat-ergebnis").innerHTML;
			const ammoniumErgebnis = document.getElementById("Ammonium-ergebnis").innerHTML;
			const phosphatErgebnis = document.getElementById("Phosphat-ergebnis").innerHTML;
			const kaliumErgebnis = document.getElementById("Kalium-ergebnis").innerHTML;
			const calciumErgebnis = document.getElementById("Calcium-ergebnis").innerHTML;
			const magnesiumErgebnis = document.getElementById("Magnesium-ergebnis").innerHTML;
			const sulfatErgebnis = document.getElementById("Sulfat-ergebnis").innerHTML;
			const eisenErgebnis = document.getElementById("Eisen-ergebnis").innerHTML;
			const manganErgebnis = document.getElementById("Mangan-ergebnis").innerHTML;
			const zinkErgebnis = document.getElementById("Zink-ergebnis").innerHTML;
			const kupferErgebnis = document.getElementById("Kupfer-ergebnis").innerHTML;
			const molybdänErgebnis = document.getElementById("Molybdän-ergebnis").innerHTML;
			const borErgebnis = document.getElementById("Bor-ergebnis").innerHTML;
			const chloridErgebnis = document.getElementById("Chlorid-ergebnis").innerHTML;
			const nickelErgebnis = document.getElementById("Nickel-ergebnis").innerHTML;
			const cobaltErgebnis = document.getElementById("Cobalt-ergebnis").innerHTML;
			const natriumErgebnis = document.getElementById("Natrium-ergebnis").innerHTML;
			const aluminiumErgebnis = document.getElementById("Aluminium-ergebnis").innerHTML;
			const siliziumErgebnis = document.getElementById("Silizium-ergebnis").innerHTML;
			const geshärteErgebnis = document.getElementById("GesHärte-ergebnis").innerHTML;
			const leitwertErgebnis = document.getElementById("Leitwert-ergebnis").innerHTML;

			// Finde den Maximalen Wert aus den Karbonaten
			function findMax() {
			const CaCarboMax = parseInt(document.getElementById("CaCarbo-ergebnis").innerHTML);
			const HydrocarboMax = parseInt(document.getElementById("Hydrocarbo-ergebnis").innerHTML);
			const SBKMax = parseInt(document.getElementById("SBK-ergebnis").innerHTML);
			const KarboMax = parseInt(document.getElementById("Karbo-ergebnis").innerHTML);
			return Math.max(CaCarboMax, HydrocarboMax, SBKMax, KarboMax); 		
			}
			
			const HCO3max = findMax().toFixed(2); // gibt HCO3max mit 2 Nachkommastellen zurück
			const HCO3maxstring = HCO3max + " mg/L";
			const khdHmax = HCO3max / 21.8;
			const khdHmaxstring = khdHmax.toFixed(2) + " dH°";

			// CSV-Headerzeile erstellen
			const Header = ["Nitrat-NO3", "Ammoniumn-NH4", "Phosphat-PO4", "Kalium-K", "Calcium-Ca", "Magnesium-Mg", 
			"Sulfat-SO4", "Eisen-Fe", "Mangan-Mn", "Zink-Zn", "Kupfer-Cu", "Molybdän-Mo", "Bor-B", "Chlorid-Cl",
			"Nickel-Ni", "Cobalt-Co", "Natrium-Na", "Aluminium-Al", "Silizium-SiO2", "Hydrogenkarbonat-HCO3", "Karbonathärte-dH°", 
			 "Gesamthärte-dH°", "Leitwert 25°C"];
			
  			// CSV-Datensatz erstellen
  			const Data = [nitratErgebnis, ammoniumErgebnis, phosphatErgebnis, kaliumErgebnis, calciumErgebnis, 
			magnesiumErgebnis, sulfatErgebnis, eisenErgebnis, manganErgebnis, zinkErgebnis, kupferErgebnis,
			molybdänErgebnis, borErgebnis, chloridErgebnis, nickelErgebnis, cobaltErgebnis, natriumErgebnis, 
			aluminiumErgebnis, siliziumErgebnis, HCO3maxstring, khdHmaxstring, geshärteErgebnis, leitwertErgebnis];
			
  			// CSV-Zeichenfolge erstellen
  			let csv = "";
  			for (let i = 0; i < Header.length; i++) {
    		csv += Header[i] + ";" + Data[i] + "\n";
			}

			// Download-Link erstellen 
    		const encodedUri = encodeURI("data:text/csv;charset=utf-8," + csv);
    		const link = document.createElement("a");
    		link.setAttribute("href", encodedUri);
    		link.setAttribute("download", "Meine Wasserwerte.csv");
    		document.body.appendChild(link);
    		link.click();
		}
	</script>

     
</html>

Mal schauen wie weit es nach und nach noch so geht..
Grobe Vorstellung für das nächste Skript, die gespeicherten Werte unter Downloads aus der CSV Datei auslesen und mit diversen Dünger in % Angaben weiter berechnen. :+1:
Wäre cool wenn das geht, mal schauen was daraus wird..

LG Kushi

5 „Gefällt mir“

Guckt euch das hier mal an. Ich habe ihr mal eine ganz einfache Aufgabe gegeben.
Nur reines Wasser und der Effekt, wenn Monokaliumphosphat hinzugefügt wird.
Das bräuchten wir für jeden Nährstoff.
Sollte sich aber irgendwie kalkulieren lassen. Ich mache mir da nebenbei auch noch Gedanken drüber - sollten wir drei doch irgendwie hinbekommen :grin:

Q: We have 10l demineralized water and want to know how the pH will be if we add 1g of monopotassium phosphate.
How can we calculate this?
Describe every step that is necessary.

A: To calculate the pH of a solution after adding monopotassium phosphate to 10 liters of demineralized water, you can follow these steps:

Step 1: Calculate the moles of monopotassium phosphate (KH2PO4) added
The molar mass of KH2PO4 is 136.09 g/mol. Therefore, 1g of KH2PO4 is equal to 1/136.09 moles.

1 g KH2PO4 / 136.09 g/mol = 0.00734 mol KH2PO4

Step 2: Calculate the final concentration of KH2PO4 in the solution
The final volume of the solution is 10 liters + 0.01 liters (assuming negligible volume of the solute), which is equal to 10.01 liters. The final concentration of KH2PO4 in the solution can be calculated using the formula:

Final concentration (mol/L) = moles of solute / final volume of solution (L)

Final concentration of KH2PO4 = 0.00734 mol / 10.01 L = 0.000733 mol/L

Step 3: Calculate the dissociation of KH2PO4 in water
KH2PO4 is a salt that undergoes partial dissociation in water. The dissociation reaction is as follows:

KH2PO4 ⇌ K+ + H2PO4-

The equilibrium constant for this reaction is given by:

Ka = ([K+][H2PO4-])/[KH2PO4]

The value of Ka for KH2PO4 is 7.2 x 10^-3.

Step 4: Calculate the concentration of H+ ions produced by the dissociation of KH2PO4
The concentration of H+ ions produced by the dissociation of KH2PO4 can be calculated using the equilibrium constant and the stoichiometry of the dissociation reaction. Since KH2PO4 dissociates to give one H+ ion, the concentration of H+ ions produced is equal to the concentration of H2PO4- ions formed. Therefore,

[H+] = [H2PO4-] = (Ka x [KH2PO4])^0.5

[H+] = (7.2 x 10^-3 x 0.000733)^0.5 = 2.00 x 10^-4 mol/L

Step 5: Calculate the pH of the solution
The pH of the solution can be calculated using the formula:

pH = -log[H+]

pH = -log(2.00 x 10^-4) = 3.70

Therefore, the pH of the solution after adding 1g of monopotassium phosphate to 10 liters of demineralized water is 3.70.

1 „Gefällt mir“

Müsstest es nur in Prozent umwandeln, dann könntest du nen Abgleich machen…

Zusammensetzung

Meine Erfahrungen waren eher bescheiden darin… :upside_down_face:

LG

Also das kann ich mir beim besten Willen nicht vorstellen daß das so ist.
Also bei meinem MPK ist das nicht so. pH 3,7 ist irre sauer. Die KI hat sich mal wieder verrannt.

Ich hatte ihr vor paar Wochen angefragt, wie schwer das Kalium in einem NPK 0-0-6 Dünger ist, Antwort: das K in ml Dünger ist 4,7g (!!). Dann darauf hingewiesen, daß das ja irre schwer sein, und dann hat sie es neu berechnet und kam halt „nur“ auf 4,2gr (LOL). Ja ne ist klar, dann müßte ne Flasche BB Grow über 5kg wiegen nur das K und H2O.

1 „Gefällt mir“

Geht mir leider genauso das GPT bei mehreren Angaben sich total verhaut!!

Zuerst gibt es mehrere Konzentrationsangaben, die der Stoffmengen, der Äquivalenz, der Massen, der des Volumens aber auch die der Teilchendichte…

  1. 1g / 1000ml = 0,001 x 100 = 0,1% // g pro Milliliter
  2. 1g / 1L = 1 x 100 = 1% // g pro Liter
  3. 1g / 1000g = 0,001 x 100 = 0,1% // g pro g wenn 1L soviel wiegt

Somit wäre eigentlich die Nr.1 die richtige Rechenweise, weil das wäre die Volumenprozentangabe und daher müssten alleine schon 50g dem Wasser zugefügt werden, um eben einen pH-Wert von 4,2 zu erreichen.

Leider möchte ich mich hier klar verabschieden von, weil man weis nicht in welcher Konzentrationsangabe es erstellt wurde! :upside_down_face:
LG

Ahja, wie gesagt, zum Rechnen ist sie einfach nicht so gut, da man da eine Fehlerquote von 0% im ganzen Prozess braucht, um auf das richtige Ergebniss zu kommen.
Habe sie das noch drei mal rechnen lassen mit der gleichen Aufgabenstellung, da kam jedes mal etwas anderes von ihr als Ergebnis zurück.
Der Weg und die Erklärung von ihr sind für mich aber schonmal etwas besser zum Verständnis der Vorgänge da. War mir bisher nicht klar, dass MKP auch H+ in die Lösung bringt.

Das ist eine ganz einfache Rechnung, da die 6 nur mit dem Faktor 1,205 umgerechnet werden muss. Gieb ihr das als richtige Anweisung und die bekommt das sicher hin.
Hört sich eher so an, als ob sie die Frage nicht richtig verstanden hat. Bei mir auch der häufigste Grund für Fehler: Ungenaue Befehle. Ist immer noch eine Maschiene, mit der wir da reden :wink:

Rein theoretisch ist die NPK Angabe ja N-Ges, P2O5 und K2O, wenn ich nun eine Masse von 1KG also rund 1000g Dünger besitze, wo 6% K2O drin sind, was dann 60g K2O entspricht, dieses mit dem Umrechnungsfaktor 0,830 multipliziert ergibt das 49,8g Kalium.

Also könnte man sagen, sofern die Dichte in flüssiger Form des Düngers dann etwa die des Wassers entspricht, also 1ml = 1g, das pro Milliliter 0,0498g Kalium zugeführt werden, was mal 1000 genommen etwa 49mg Kalium pro ml entspricht.

Genau, eigentlich ganz einfach. Aber mit Zahlen hat das Ding echt noch Probleme.
Plus kannst du inzwischen auch irgendwie mit Wolfram über ein AddOn verbinden.
Mir auf jeden Fall aktuell zu hoch, aber mit solchen Kalkulationen seid du und Gernot glaube ich bisschen fitter. Da hätte man wohl den richtigen Werkzeugkasten, um auch mit GPT komplizierte Sachen zu berechnen.

Ich versuche erstmal weiter die Basics zu verstehen. Also wie sich so ein Salz überhaupt genau verhält, wenn man es in Wasser löst. Ganz so einfach wie „da schwirren H+ und OH- im Wasser“ ist es ja bei Weitem nicht :sweat_smile:
Sobald ich mich da mal komplett reindenken kann, gehe ich das weiter an. Aktuell hat der Ablauf dahinter für mich halt Priorität, wie es in die Pflanze kommt und was in ihr damit dann passiert.
Bringt ja auch nichts, wenn wir uns alle am selben Thema abarbeiten. Spezialisierung und so .. :wink:

1 „Gefällt mir“

@GernotReinhardsen @KushMuss Ich habe den Teil zum pH aus Bugbees Paper mal kurz durch GPT bisschen erklären lassen. Wenn wir da einfach nach dem gehen, was Fernandez und Bugbee da sagen, können wir wohl das meiste ignorieren und die Wichtigkeit des Phosphat-Puffer, den Kushi schon vor zwei Jahren mit Herrn Horn besprochen hat, auch als wissenschaftlich irgendwie bestätigt ansehen.
Erklärt auch irgendwie, warum bei mir alles mehr oder weniger bei pH 6 landet und sich da einpendelt bei den Tests (ohne MOs/organics^^).

1 „Gefällt mir“

An diesem bin ich merkwürdiger Weise in meinem Rechner Skript auch grade dran :upside_down_face:
Mein folgendes Wissen beruht eigentlich darauf, das ich mir dies schon etwas länger zusammen gesucht habe um auch nun meinen Leitwert bei Düngerzugaben exakter berechnen zu können, weil das funktionierte Damals ja eigentlich überhaupt nicht! :face_with_head_bandage:

Laut Wikipedia gibt es dazu folgende Aussage:
In wässriger Lösung existieren Phosphat-Anionen in drei Formen. Unter stark basischen Bedingungen liegt das Phosphat-Anion hauptsächlich als (PO43−) vor, während unter schwach basischen Bedingungen das Hydrogenphosphat -Anion (HPO42−) dominiert. Unter schwach sauren Bedingungen liegt hauptsächlich das Dihydrogenphosphat -Anion (H2PO4−) vor. In stark saurer wässriger Lösung ist Phosphorsäure (H3PO4) die Hauptform.

Des Weiteren nehmen Pflanzen Phosphor gern aus diesen 3 genannten Form auf, aber es wird speziell darauf verwiesen, das sie es aus dem Boden nur in der Form PO₄³⁻ aufnehmen, was nach meiner nun folgenden erarbeiteten Sichtweise so beim besten Willen nicht sein kann!

Denn jetzt gibt es noch die pH-Bereiche von GPT zu den 3 Formen:

  • Bei einem hohen pH-Wert (über 12) existiert das Phosphat-Ion PO₄³⁻, das auch als Tribasische Form bezeichnet wird.
  • Bei einem pH-Wert von 7 bis 12 (im alkalischen Bereich) existiert das Dihydrogenphosphat-Ion HPO₄²⁻, auch als Monobasische Form bekannt.
  • Bei einem pH-Wert von 2 bis 7 (im sauren Bereich) existiert das Dihydrogenphosphat-Ion H₂PO₄⁻, auch als Dihydrogenphosphat oder Dihydrogenphosphation bekannt.

Um nun folgend den Leitwert etwas exakter berechnen zu können, muss man sich diese Tabelle hier mal etwas genauer anschauen: Phosphorsäure H3PO4 (aqion.de)

Ich möchte ab hier gern erwähnen, das ich zwischen der pH Benutzung von Hydro und Erde ungern weiter fachsimpeln möchte und klar beide vereinen möchte und hier sage ein 6 pH vereint alles.
Des Weiteren weis ich nicht, was die Ladungsberücksichtigung von PO4 bei eine Wasseranalyse aussagt, ob hier nur PO4 oder das PO₄³⁻ gemeint ist.. leider!
Das Ganze ist etwas verwirrend!

Nun kommt halt folgende Beispielberechnung dabei raus:
10 mg/L P2O5 x 1.496 = 14.96 mg/L PO4 (nachfolgen mal gerundet)

Richtig wäre aber, das ich erst das P2O5 zu P umrechne:
10mg/L P2O5 x 0,436 = 4,36 mg/L P

Als nächstes besitze ich bei einem pH-Wert von 6 etwa 94,5% H2PO4 und 5,5% HPO4 und komme leider an meine Mathematischen Verständnisse!
Rechne ich erst das P zu H2PO4 um, dann nochmal P zu HPO4 und nehme dann die Prozent ein, oder nehme ich P erst jeweils durch die Prozente und rechne sie dann immer H2PO4 und HPO4 um?!

Faktor für P in HPO4 umrechnen = 0,322
Faktor für P in H2PO4 = 0,319

Allerdings daraus ersichtlich, ernährt sich eine Pflanze in einem Hydroponischen System wohl eher nur von H2PO4 und HPO4-2 und folglich muss ich das wohl dann auch so in meine theoretische Berechnung für den Leitwert einer Düngerzugabe fallen lassen, um nicht wieder wie beim letzten mal umständlich oder überhaupt erst gar nicht in die Nähe des Berechnet/IST-gemessen Leitwertes zu kommen. :joy:

Hoffe man kann es gebrauchen und ich bekomme es auch so in HTML umgesetzt.. :wink:

1 „Gefällt mir“