diff --git a/CMakeLists.txt b/CMakeLists.txt
index 533ff6f2a65df765ac12d6782ebd345904842139..214e293a6df66fc39c74e79bdecdb969d751b670 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,12 +4,14 @@ project(ehigeneratorsa)
 
 set(SRC_FILES
 	main.cpp
+	componant.cpp
 	cap.cpp
 	resistor.cpp
 	constantphase.cpp
 	warburg.cpp
 	model.cpp
 	tokenize.cpp
+	paralellseriel.cpp
 )
 
 find_package(PkgConfig REQUIRED)
diff --git a/componant.cpp b/componant.cpp
index 8d1c8b69c3fce7bea45c73efd06983e3c419a92f..395f12ac4551d725758aa614ab29a2068925c398 100644
--- a/componant.cpp
+++ b/componant.cpp
@@ -1 +1,49 @@
- 
+#include "componant.h"
+#include <assert.h>
+#include "paralellseriel.h"
+#include "resistor.h"
+#include "cap.h"
+#include "constantphase.h"
+#include "warburg.h"
+
+Componant* Componant::copy(Componant* componant)
+{
+	switch(getComponantChar(componant))
+	{
+		case 'r':
+			return new Resistor(*dynamic_cast<Resistor*>(componant));
+		case 'c':
+			return new Cap(*dynamic_cast<Cap*>(componant));
+		case 'p':
+			return new Cpe(*dynamic_cast<Cpe*>(componant));
+		case 'w':
+			return new Warburg(*dynamic_cast<Warburg*>(componant));
+		case 'l':
+			return new Parallel(*dynamic_cast<Parallel*>(componant));
+		case 's':
+			return new Serial(*dynamic_cast<Serial*>(componant));
+		default:
+			std::cout<<"Error: unimplmented type copy for "<<getComponantChar(componant)<<'\n';
+			assert(0);
+			break;
+	}
+	return nullptr;
+}
+
+char Componant::getComponantChar(Componant* componant)
+{
+	if(dynamic_cast<Resistor*>(componant))
+		return 'r';
+	if(dynamic_cast<Cap*>(componant))
+		return 'c';
+	if(dynamic_cast<Cpe*>(componant))
+		return 'p';
+	if(dynamic_cast<Warburg*>(componant))
+		return 'w';
+	if(dynamic_cast<Parallel*>(componant))
+		return 'l';
+	if(dynamic_cast<Serial*>(componant))
+		return 's';
+
+	return 'x';
+}
diff --git a/componant.h b/componant.h
index 7f0aa4229671a0e9b766ea20e0a747cd39b83d44..ebf924ab96524ccfa5b114ab175c163dd9a84664 100644
--- a/componant.h
+++ b/componant.h
@@ -19,4 +19,7 @@ class Componant
 		virtual void setParam(const std::vector<double>& param){};
 		virtual size_t paramCount(){return 0;}
 		virtual ~Componant() = default;
+
+		static Componant* copy(Componant* componant);
+		static char getComponantChar(Componant* componant);
 };
diff --git a/main.cpp b/main.cpp
index 74ebc3e732954ac2a6824b7f1ff60f7daefb9edd..055d9cfda9a0c8fac0e061b65afa049862bc2349 100644
--- a/main.cpp
+++ b/main.cpp
@@ -14,7 +14,7 @@ void runSingle()
 	std::cout<<"Compnants: \n";
 	for(Componant* componant : model.getFlatComponants())
 	{
-		std::cout<<Model::getComponantChar(componant)<<"{";
+		std::cout<<Componant::getComponantChar(componant)<<"{";
 		for(size_t i = 0; i < componant->paramCount(); ++i)
 		{
 			std::cout<<componant->getParam()[i];
@@ -34,6 +34,13 @@ void runSingle()
 	for(const Model::DataPoint& res : results)
 		std::cout<<"omega: "<<res.omega<<" real = "<<res.im.real()<<" im = "<<res.im.imag()<<'\n';
 
+	Model modelCopy(model);
+	results = modelCopy.sweep(omega);
+
+	for(const Model::DataPoint& res : results)
+		std::cout<<"omega: "<<res.omega<<" real = "<<res.im.real()<<" im = "<<res.im.imag()<<'\n';
+
+
 	std::cout<<"time taken: "<<duration.count()<<" us"<<'\n';
 }
 
diff --git a/model.cpp b/model.cpp
index 1b510ec3351baf5c94ecd3f032b4a4bed3dd3957..604ffbf85885302c3b5cfa9f0da747c30b56bf4b 100644
--- a/model.cpp
+++ b/model.cpp
@@ -1,50 +1,12 @@
 #include <model.h>
 #include <iostream>
+#include <assert.h>
 #include "tokenize.h"
 #include "cap.h"
 #include "resistor.h"
 #include "constantphase.h"
 #include "warburg.h"
-
-Model::Paralell::Paralell(std::vector<Componant*> componantsIn): componants(componantsIn)
-{
-}
-
-Model::Paralell::~Paralell()
-{
-	for(Componant* componant : componants)
-		delete componant;
-}
-
-std::complex<double> Model::Paralell::execute(double omega)
-{
-	std::complex<double> accum(0,0);
-	for(Componant* componant : componants)
-	{
-		accum += std::complex<double>(1,0)/componant->execute(omega);
-	}
-	return std::complex<double>(1,0)/accum;
-}
-
-Model::Serial::Serial(std::vector<Componant*> componantsIn): componants(componantsIn)
-{
-}
-
-Model::Serial::~Serial()
-{
-	for(Componant* componant : componants)
-		delete componant;
-}
-
-std::complex<double> Model::Serial::execute(double omega)
-{
-	std::complex<double> accum(0,0);
-	for(Componant* componant : componants)
-	{
-		accum += componant->execute(omega);
-	}
-	return accum;
-}
+#include "paralellseriel.h"
 
 size_t Model::opposingBraket(const std::string& str, size_t index, char bracketChar)
 {
@@ -180,7 +142,7 @@ Componant *Model::processBracket(std::string& str)
 			}
 		}
 		if(componants.size() > 1)
-			nodes.push_back(new Paralell(componants));
+			nodes.push_back(new Parallel(componants));
 		else if(componants.size() == 1)
 			nodes.push_back(componants[0]);
 		else
@@ -202,6 +164,21 @@ Model::Model(const std::string& str): _modelStr(str)
 	_model = processBrackets(strCpy, bracketCounter);
 }
 
+Model::Model(const Model& in)
+{
+	operator=(in);
+}
+
+Model& Model::operator=(const Model& in)
+{
+	delete _model;
+	_modelStr = in._modelStr;
+	_bracketComponants.clear();
+	_flatComponants.clear();
+	_model = Componant::copy(in._model);
+	return *this;
+}
+
 Model::~Model()
 {
 	delete _model;
@@ -225,7 +202,7 @@ Model::DataPoint Model::execute(double omega)
 
 void Model::addComponantToFlat(Componant* componant)
 {
-	Paralell* paralell = dynamic_cast<Paralell*>(componant);
+	Parallel* paralell = dynamic_cast<Parallel*>(componant);
 	if(paralell)
 	{
 		for(Componant* element : paralell->componants)
@@ -347,18 +324,3 @@ size_t Model::getFlatParametersCount()
 	return count;
 }
 
-char Model::getComponantChar(Componant* componant)
-{
-	if(dynamic_cast<Resistor*>(componant))
-		return 'r';
-	if(dynamic_cast<Cap*>(componant))
-		return 'c';
-	if(dynamic_cast<Cpe*>(componant))
-		return 'p';
-	if(dynamic_cast<Warburg*>(componant))
-		return 'w';
-
-	return 'x';
-}
-
-
diff --git a/model.h b/model.h
index 57076525d340df1f6e6556adb7ff9acbe7fd346c..908823d37322c7d5266b7765536dc428453a2d6f 100644
--- a/model.h
+++ b/model.h
@@ -24,27 +24,8 @@ public:
 		Range(double startI, double endI, size_t countI): start(startI), end(endI), count(countI){}
 		Range() = default;
 	};
-private:
-	class Paralell: public Componant
-	{
-	public:
-		std::vector<Componant*> componants;
-
-		Paralell(std::vector<Componant*> componantsIn = std::vector<Componant*>());
-		~Paralell();
-		virtual std::complex<double> execute(double omaga) override;
-	};
-
-	class Serial: public Componant
-	{
-	public:
-		std::vector<Componant*> componants;
-
-		Serial(std::vector<Componant*> componantsIn = std::vector<Componant*>());
-		~Serial();
-		virtual std::complex<double> execute(double omaga) override;
-	};
 
+private:
 	size_t opposingBraket(const std::string& str, size_t index, char bracketChar = ')');
 	size_t deepestBraket(const std::string& str);
 	Componant *processBrackets(std::string& str, size_t& bracketCounter);
@@ -60,6 +41,8 @@ private:
 
 public:
 	Model(const std::string& str);
+	Model(const Model& in);
+	Model& operator=(const Model& in);
 	~Model();
 	DataPoint execute(double omaga);
 	std::vector<DataPoint> sweep(const Range& omega);
@@ -68,5 +51,4 @@ public:
 	std::vector<Componant*> getFlatComponants();
 	size_t getFlatParametersCount();
 	bool setFlatParameters(const std::vector<double>& parameters);
-	static char getComponantChar(Componant* componant);
 };
diff --git a/paralellseriel.cpp b/paralellseriel.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..041d0f6afb8fed835194af31440bb9274f835134
--- /dev/null
+++ b/paralellseriel.cpp
@@ -0,0 +1,67 @@
+#include "paralellseriel.h"
+
+Parallel::Parallel(std::vector<Componant*> componantsIn): componants(componantsIn)
+{
+}
+
+Parallel::Parallel(const Parallel& in)
+{
+	operator=(in);
+}
+
+void Parallel::operator=(const Parallel& in)
+{
+	componants.clear();
+	componants.reserve(in.componants.size());
+	for(Componant* componant : in.componants)
+		componants.push_back(copy(componant));
+}
+
+Parallel::~Parallel()
+{
+	for(Componant* componant : componants)
+		delete componant;
+}
+
+std::complex<double> Parallel::execute(double omega)
+{
+	std::complex<double> accum(0,0);
+	for(Componant* componant : componants)
+	{
+		accum += std::complex<double>(1,0)/componant->execute(omega);
+	}
+	return std::complex<double>(1,0)/accum;
+}
+
+Serial::Serial(std::vector<Componant*> componantsIn): componants(componantsIn)
+{
+}
+
+Serial::Serial(const Serial& in)
+{
+	operator=(in);
+}
+
+void Serial::operator=(const Serial& in)
+{
+	componants.clear();
+	componants.reserve(in.componants.size());
+	for(Componant* componant : in.componants)
+		componants.push_back(copy(componant));
+}
+
+Serial::~Serial()
+{
+	for(Componant* componant : componants)
+		delete componant;
+}
+
+std::complex<double> Serial::execute(double omega)
+{
+	std::complex<double> accum(0,0);
+	for(Componant* componant : componants)
+	{
+		accum += componant->execute(omega);
+	}
+	return accum;
+}
diff --git a/paralellseriel.h b/paralellseriel.h
new file mode 100644
index 0000000000000000000000000000000000000000..896370d2432a6bb3721fb00b1e05ac996947fc4e
--- /dev/null
+++ b/paralellseriel.h
@@ -0,0 +1,28 @@
+#pragma once
+#include <vector>
+#include <complex>
+#include "componant.h"
+
+class Parallel: public Componant
+{
+public:
+	std::vector<Componant*> componants;
+
+	Parallel(std::vector<Componant*> componantsIn = std::vector<Componant*>());
+	Parallel(const Parallel& in);
+	void operator=(const Parallel& in);
+	~Parallel();
+	virtual std::complex<double> execute(double omaga) override;
+};
+
+class Serial: public Componant
+{
+public:
+	std::vector<Componant*> componants;
+
+	Serial(std::vector<Componant*> componantsIn = std::vector<Componant*>());
+	Serial(const Serial& in);
+	void operator=(const Serial& in);
+	~Serial();
+	virtual std::complex<double> execute(double omaga) override;
+};