initial commit

8_9_Atomkern/code/Atomkern/Prueffolge.cpp

@@ -0,0 +1,68 @@
+/**
+ * OPR-Praktikum SS 2012
+ * Aufgabe 9
+ * @author Thomas Mahr
+ */
+
+#include "Prueffolge.h"
+#include <iostream>
+#include <sstream>
+using namespace std;
+
+Prueffolge::Prueffolge()
+{
+}
+	
+Prueffolge::~Prueffolge()
+{
+	for(list<Prueffall*>::iterator it=prueffaelle.begin(); it!=prueffaelle.end(); it++)	
+	{ 
+		delete *it;
+	}
+}
+
+void Prueffolge::anmelden(std::string bezeichnung, Prueffunktion test)
+{
+	Prueffall* tf = new Prueffall(bezeichnung,test);
+	tf->funktion = test;
+	prueffaelle.push_back(tf);
+}	
+
+
+void Prueffolge::ausfuehren()
+{
+	int zaehlerTestBestanden = 0;
+	for(list<Prueffall*>::iterator it=prueffaelle.begin(); it!=prueffaelle.end(); it++)	
+	{ 
+		cout << "PRUEFUNG " << (*it)->bezeichnung << ": ";
+		try
+		{
+			(*it)->funktion(); 
+			zaehlerTestBestanden++;
+			cout << "ERFOLGREICH\n";
+		}
+		catch(Fehler f)
+		{
+			cout << f.beschreibung() << endl;
+		}
+	}
+	
+	cout << zaehlerTestBestanden << " von " << prueffaelle.size() << " Pruefungen erfolgreich\n";
+}
+
+void Prueffolge::sicherstellen(bool b, std::string dateiName, int zeile)
+{
+	if(!b)
+	{
+		throw Fehler(dateiName, zeile);
+	}
+}
+
+
+string Prueffolge::Fehler::beschreibung()
+{
+	stringstream s;
+	s << "FEHLER in " << dateiName << " Zeile " << zeile;
+	return s.str();
+}
+

8_9_Atomkern/code/Atomkern/Prueffolge.h

@@ -0,0 +1,47 @@
+/**
+ * OPR-Praktikum SS 2012
+ * Aufgabe 9
+ * @author Thomas Mahr
+ */
+
+#pragma once
+#include <list>
+#include <string>
+
+#define SICHERSTELLEN(exp) ( sicherstellen(exp, __FILE__, __LINE__) )
+
+class Prueffolge
+{
+public:
+
+	Prueffolge();
+	virtual ~Prueffolge();
+	void ausfuehren();
+
+protected:
+
+	typedef void (*Prueffunktion)();
+
+	struct Fehler
+	{
+		std::string dateiName;
+		int zeile;
+		Fehler(std::string dateiName, int zeile) : dateiName(dateiName), zeile(zeile) {}		
+		std::string beschreibung();
+	};
+	
+	struct Prueffall
+	{
+		std::string bezeichnung;
+		Prueffunktion funktion;
+		Prueffall(std::string bezeichnung, Prueffunktion funktion) : bezeichnung(bezeichnung), funktion(funktion) {}
+	};
+
+	void anmelden(std::string bezeichnung, Prueffunktion test);
+	
+	static void sicherstellen(bool b, std::string dateiName, int zeile);
+
+private:
+
+	std::list<Prueffall*> prueffaelle;
+};

8_9_Atomkern/code/Atomkern/PrueffolgeAtomkern.cpp

@@ -0,0 +1,92 @@
+/**
+ * OPR-Praktikum SS 2012
+ * Aufgabe 9
+ * @author Thomas Mahr
+ */
+
+#include "PrueffolgeAtomkern.h"
+#include "Atomkern.h"
+#include <sstream>
+using namespace std;
+
+PrueffolgeAtomkern::PrueffolgeAtomkern()
+{
+	anmelden("Atomkern erstellen", &pruefungAtomkernErstellen);
+	anmelden("Atomkern ausgeben", &pruefungAusgabe);
+	anmelden("Proton", &pruefungProton);
+	anmelden("Neutron", &pruefungNeutron);
+	anmelden("operator+=", &pruefungOperatorPlusGleich);
+	anmelden("operator-=", &pruefungOperatorMinusGleich);
+	anmelden("Kernfusion", &pruefungKernfusion);
+	anmelden("Kernspaltung", &pruefungKernspaltung);	
+}
+
+void PrueffolgeAtomkern::pruefungAtomkernErstellen() 
+{
+	Atomkern kern("Pu",239,94);
+	SICHERSTELLEN(kern.symbol()=="Pu");
+	SICHERSTELLEN(kern.ordnungszahl()==94);	
+	SICHERSTELLEN(kern.massenzahl()==239);	
+}
+
+void PrueffolgeAtomkern::pruefungAusgabe() 
+{
+	Atomkern kern("C",12,6);	
+	stringstream s;
+	s << "Atomkern = " << kern << ".";
+	SICHERSTELLEN(s.str()=="Atomkern = C(12,6).");
+}
+
+void PrueffolgeAtomkern::pruefungProton() 
+{
+	SICHERSTELLEN(Atomkern::PROTON.ordnungszahl()==1);
+	SICHERSTELLEN(Atomkern::PROTON.massenzahl()==1);
+}
+
+void PrueffolgeAtomkern::pruefungNeutron() 
+{
+	SICHERSTELLEN(Atomkern::NEUTRON.ordnungszahl()==0);
+	SICHERSTELLEN(Atomkern::NEUTRON.massenzahl()==1);
+}
+
+void PrueffolgeAtomkern::pruefungOperatorPlusGleich() 
+{
+	Atomkern kern("C",12,6);	
+	kern += Atomkern::NEUTRON;
+	SICHERSTELLEN(kern.ordnungszahl()==6);
+	SICHERSTELLEN(kern.massenzahl()==13);
+	kern += Atomkern::PROTON;
+	SICHERSTELLEN(kern.ordnungszahl()==7);
+	SICHERSTELLEN(kern.massenzahl()==14);
+}
+
+void PrueffolgeAtomkern::pruefungOperatorMinusGleich() 
+{
+	Atomkern kern("C",12,6);	
+	kern -= Atomkern::NEUTRON;
+	SICHERSTELLEN(kern.ordnungszahl()==6);
+	SICHERSTELLEN(kern.massenzahl()==11);
+	kern -= Atomkern::PROTON;
+	SICHERSTELLEN(kern.ordnungszahl()==5);
+	SICHERSTELLEN(kern.massenzahl()==10);
+}
+
+void PrueffolgeAtomkern::pruefungKernfusion()
+{
+	const Atomkern DEUTERIUM("D",2,1);
+	const Atomkern TRITIUM("T",3,1);
+	const Atomkern HELIUM("He",4,2);	
+	Atomkern ergebnis = DEUTERIUM + TRITIUM - Atomkern::NEUTRON;
+	SICHERSTELLEN(ergebnis.ordnungszahl()==2);
+	SICHERSTELLEN(ergebnis.massenzahl()==4);	
+	SICHERSTELLEN(ergebnis==HELIUM);
+}
+
+void PrueffolgeAtomkern::pruefungKernspaltung()
+{
+	const Atomkern PLUTONIUM("Pu",239,94);
+	const Atomkern BARIUM("Ba",144,56);
+	const Atomkern STRONTIUM("Sr",94,38);
+	SICHERSTELLEN(PLUTONIUM + Atomkern::NEUTRON == BARIUM + STRONTIUM + 2*Atomkern::NEUTRON);
+}
+

8_9_Atomkern/code/Atomkern/PrueffolgeAtomkern.h

@@ -0,0 +1,26 @@
+/**
+ * OPR-Praktikum SS 2012
+ * Aufgabe 9
+ * @author Thomas Mahr
+ */
+
+#pragma once
+#include "Prueffolge.h"
+
+class PrueffolgeAtomkern : public Prueffolge
+{
+public:
+
+	PrueffolgeAtomkern();
+
+private:
+
+	static void pruefungAtomkernErstellen();
+	static void pruefungAusgabe();
+	static void pruefungProton();
+	static void pruefungNeutron();
+	static void pruefungOperatorPlusGleich();
+	static void pruefungOperatorMinusGleich();
+	static void pruefungKernfusion();
+	static void pruefungKernspaltung();
+};

8_9_Atomkern/code/Atomkern/main.cpp

@@ -0,0 +1,13 @@
+/**
+ * OPR-Praktikum SS 2012
+ * Aufgabe 9
+ * @author Thomas Mahr
+ */
+
+#include "PrueffolgeAtomkern.h"
+
+int main() 
+{
+	PrueffolgeAtomkern prueffolgeAtomkern;
+	prueffolgeAtomkern.ausfuehren();
+}

8_9_Atomkern/code/Reaktor/Prueffolge.cpp

@@ -0,0 +1,68 @@
+/**
+ * OPR-Praktikum SS 2012
+ * Aufgabe 9
+ * @author Thomas Mahr
+ */
+
+#include "Prueffolge.h"
+#include <iostream>
+#include <sstream>
+using namespace std;
+
+Prueffolge::Prueffolge()
+{
+}
+	
+Prueffolge::~Prueffolge()
+{
+	for(list<Prueffall*>::iterator it=prueffaelle.begin(); it!=prueffaelle.end(); it++)	
+	{ 
+		delete *it;
+	}
+}
+
+void Prueffolge::anmelden(std::string bezeichnung, Prueffunktion test)
+{
+	Prueffall* tf = new Prueffall(bezeichnung,test);
+	tf->funktion = test;
+	prueffaelle.push_back(tf);
+}	
+
+
+void Prueffolge::ausfuehren()
+{
+	int zaehlerTestBestanden = 0;
+	for(list<Prueffall*>::iterator it=prueffaelle.begin(); it!=prueffaelle.end(); it++)	
+	{ 
+		cout << "PRUEFUNG " << (*it)->bezeichnung << ": ";
+		try
+		{
+			(*it)->funktion(); 
+			zaehlerTestBestanden++;
+			cout << "ERFOLGREICH\n";
+		}
+		catch(Fehler f)
+		{
+			cout << f.beschreibung() << endl;
+		}
+	}
+	
+	cout << zaehlerTestBestanden << " von " << prueffaelle.size() << " Pruefungen erfolgreich\n";
+}
+
+void Prueffolge::sicherstellen(bool b, std::string dateiName, int zeile)
+{
+	if(!b)
+	{
+		throw Fehler(dateiName, zeile);
+	}
+}
+
+
+string Prueffolge::Fehler::beschreibung()
+{
+	stringstream s;
+	s << "FEHLER in " << dateiName << " Zeile " << zeile;
+	return s.str();
+}
+

8_9_Atomkern/code/Reaktor/Prueffolge.h

@@ -0,0 +1,47 @@
+/**
+ * OPR-Praktikum SS 2012
+ * Aufgabe 9
+ * @author Thomas Mahr
+ */
+
+#pragma once
+#include <list>
+#include <string>
+
+#define SICHERSTELLEN(exp) ( sicherstellen(exp, __FILE__, __LINE__) )
+
+class Prueffolge
+{
+public:
+
+	Prueffolge();
+	virtual ~Prueffolge();
+	void ausfuehren();
+
+protected:
+
+	typedef void (*Prueffunktion)();
+
+	struct Fehler
+	{
+		std::string dateiName;
+		int zeile;
+		Fehler(std::string dateiName, int zeile) : dateiName(dateiName), zeile(zeile) {}		
+		std::string beschreibung();
+	};
+	
+	struct Prueffall
+	{
+		std::string bezeichnung;
+		Prueffunktion funktion;
+		Prueffall(std::string bezeichnung, Prueffunktion funktion) : bezeichnung(bezeichnung), funktion(funktion) {}
+	};
+
+	void anmelden(std::string bezeichnung, Prueffunktion test);
+	
+	static void sicherstellen(bool b, std::string dateiName, int zeile);
+
+private:
+
+	std::list<Prueffall*> prueffaelle;
+};

8_9_Atomkern/code/Reaktor/PrueffolgeReaktor.cpp

@@ -0,0 +1,71 @@
+/**
+ * OPR-Praktikum SS 2012
+ * Aufgabe 9
+ * @author Thomas Mahr
+ */
+
+#include "PrueffolgeReaktor.h"
+#include "Atomkern.h"
+#include "Reaktor.h"
+using namespace std;
+
+const Atomkern PrueffolgeReaktor::DEUTERIUM("D",2,1);
+const Atomkern PrueffolgeReaktor::TRITIUM("T",3,1);
+const Atomkern PrueffolgeReaktor::HELIUM4("He",4,2);	
+
+PrueffolgeReaktor::PrueffolgeReaktor()
+{
+	anmelden("Reaktor erstellen", &pruefungReaktorErstellen);
+	anmelden("Reaktor befuellen und komplett entleeren", &pruefungReaktorBetrieb1);
+	anmelden("Kernfusion mit Wasserstoff", &pruefungReaktorBetrieb2);
+	anmelden("Kernspaltung mit Plutonium", &pruefungReaktorBetrieb3);
+}
+
+void PrueffolgeReaktor::pruefungReaktorErstellen() 
+{
+	Reaktor reaktor;
+	// Ein gerade erstellter Reaktor enthält kein Kernmaterial
+	SICHERSTELLEN(*reaktor==Atomkern(0,0));
+}
+
+void PrueffolgeReaktor::pruefungReaktorBetrieb1() 
+{
+	Reaktor reaktor;	
+	// Reaktor mit Deuterium füllen
+	reaktor < DEUTERIUM;
+	SICHERSTELLEN(*reaktor==DEUTERIUM);
+	// Reaktor mit Tritium füllen
+	reaktor < TRITIUM;
+	// Auf (instabiles) Fusionsprodukt prüfen
+	SICHERSTELLEN(*reaktor==Atomkern(5,2));
+	// Reaktor komplett entleeren
+	~reaktor;
+	SICHERSTELLEN(*reaktor==Atomkern(0,0));
+}
+
+void PrueffolgeReaktor::pruefungReaktorBetrieb2() 
+{
+	Reaktor reaktor;	
+	// Bei der Verschmelzung von Deuterium mit Tritium wird ein Neutron frei. 
+	reaktor < DEUTERIUM < TRITIUM > Atomkern::NEUTRON;
+	// Zurück bleibt Helium.
+	SICHERSTELLEN(*reaktor==HELIUM4);
+}
+
+void PrueffolgeReaktor::pruefungReaktorBetrieb3() 
+{
+	Reaktor reaktor;	
+	const Atomkern PLUTONIUM("Pu",239,94);
+	const Atomkern BARIUM("Ba",144,56);
+	const Atomkern STRONTIUM("Sr",94,38);
+
+	// Plutonium spaltet sich bei Wechselwirkung mit einem Neutron in Barium und Strontium und gibt dabei zwei Neutronen frei.
+	reaktor < PLUTONIUM < Atomkern::NEUTRON;
+	SICHERSTELLEN(*reaktor==Atomkern(240,94));
+	reaktor > BARIUM > STRONTIUM > 2*Atomkern::NEUTRON;
+	SICHERSTELLEN(*reaktor==Atomkern(0,0));
+	
+	// Komplette Reaktion in einem Aufruf:
+	reaktor < PLUTONIUM < Atomkern::NEUTRON > BARIUM > STRONTIUM > 2*Atomkern::NEUTRON;
+	SICHERSTELLEN(*reaktor==Atomkern(0,0));
+}

8_9_Atomkern/code/Reaktor/PrueffolgeReaktor.h

@@ -0,0 +1,28 @@
+/**
+ * OPR-Praktikum SS 2012
+ * Aufgabe 9
+ * @author Thomas Mahr
+ */
+
+#pragma once
+#include "Prueffolge.h"
+class Atomkern;
+
+class PrueffolgeReaktor : public Prueffolge
+{
+public:
+
+	PrueffolgeReaktor();
+
+private:
+
+	static const Atomkern DEUTERIUM;
+	static const Atomkern TRITIUM;
+	static const Atomkern HELIUM4;	
+
+	static void pruefungReaktorErstellen();
+	static void pruefungReaktorBetrieb1();
+	static void pruefungReaktorBetrieb2();
+	static void pruefungReaktorBetrieb3();
+};
+

8_9_Atomkern/code/Reaktor/main.cpp

@@ -0,0 +1,13 @@
+/**
+ * OPR-Praktikum SS 2012
+ * Aufgabe 9
+ * @author Thomas Mahr
+ */
+
+#include "PrueffolgeReaktor.h"
+
+int main() 
+{
+	PrueffolgeReaktor prueffolgeReaktor;
+	prueffolgeReaktor.ausfuehren();
+}