diff --git a/Common/engine_interface_base.cpp b/Common/engine_interface_base.cpp
index f751fc6..4db393c 100644
--- a/Common/engine_interface_base.cpp
+++ b/Common/engine_interface_base.cpp
@@ -18,8 +18,9 @@
 #include "engine_interface_base.h"
 #include "string"
 
-Engine_Interface_Base::Engine_Interface_Base()
+Engine_Interface_Base::Engine_Interface_Base(Operator_Base* base_op)
 {
+	m_Op_Base = base_op;
 	m_InterpolType = NO_INTERPOLATION;
 }
 
diff --git a/Common/engine_interface_base.h b/Common/engine_interface_base.h
index e71ed99..c568ce6 100644
--- a/Common/engine_interface_base.h
+++ b/Common/engine_interface_base.h
@@ -20,6 +20,8 @@
 
 #include "tools/global.h"
 
+class Operator_Base;
+
 //! This is the abstact base for all Engine Interface classes.
 /*!
 	 This is the abstact base for all Engine Interface classes. It will provide unified access to the field information of the corresponding engine.
@@ -30,6 +32,11 @@ class Engine_Interface_Base
 public:
 	enum InterpolationType { NO_INTERPOLATION, NODE_INTERPOLATE, CELL_INTERPOLATE };
 
+	//! Set the operator used for this engine interface.
+	virtual void SetOperator(Operator_Base* base_op) {m_Op_Base=base_op;}
+	//! Get the operator used for this engine interface.
+	virtual const Operator_Base* GetOperator() const {return m_Op_Base;}
+
 	//! Set the current interpolation type \sa GetInterpolationType
 	void SetInterpolationType(InterpolationType type) {m_InterpolType=type;}
 	//! Set the current interpolation type \sa GetInterpolationType
@@ -57,7 +64,9 @@ public:
 	virtual unsigned int GetNumberOfTimesteps() const =0;
 
 protected:
-	Engine_Interface_Base();
+	Engine_Interface_Base(Operator_Base* base_op);
+
+	Operator_Base* m_Op_Base;
 
 	InterpolationType m_InterpolType;
 };
diff --git a/Common/process_efield.cpp b/Common/process_efield.cpp
index 0aa55c4..c55a10f 100644
--- a/Common/process_efield.cpp
+++ b/Common/process_efield.cpp
@@ -19,7 +19,7 @@
 #include "time.h"
 #include "process_efield.h"
 
-ProcessEField::ProcessEField(Operator_Base* op, Engine* eng) : Processing(op)
+ProcessEField::ProcessEField(Engine_Interface_Base* eng_if, Engine* eng) : Processing(eng_if)
 {
 	Eng = eng;
 }
diff --git a/Common/process_efield.h b/Common/process_efield.h
index 35afc40..1fd7709 100644
--- a/Common/process_efield.h
+++ b/Common/process_efield.h
@@ -29,7 +29,7 @@
 class ProcessEField : public Processing
 {
 public:
-	ProcessEField(Operator_Base* op, Engine* eng);
+	ProcessEField(Engine_Interface_Base* eng_if, Engine* eng);
 	virtual ~ProcessEField();
 
 	virtual void InitProcess();
diff --git a/Common/process_hfield.cpp b/Common/process_hfield.cpp
index dd96902..c05e972 100644
--- a/Common/process_hfield.cpp
+++ b/Common/process_hfield.cpp
@@ -19,7 +19,7 @@
 #include "tools/global.h"
 #include "process_hfield.h"
 
-ProcessHField::ProcessHField(Operator_Base* op, Engine* eng) : ProcessEField(op, eng)
+ProcessHField::ProcessHField(Engine_Interface_Base* eng_if, Engine* eng) : ProcessEField(eng_if, eng)
 {
 }
 
diff --git a/Common/process_hfield.h b/Common/process_hfield.h
index 22e00ce..5d16355 100644
--- a/Common/process_hfield.h
+++ b/Common/process_hfield.h
@@ -28,7 +28,7 @@
 class ProcessHField : public ProcessEField
 {
 public:
-	ProcessHField(Operator_Base* op, Engine* eng);
+	ProcessHField(Engine_Interface_Base* eng_if, Engine* eng);
 	virtual ~ProcessHField();
 
 	virtual void InitProcess();
diff --git a/Common/processcurrent.cpp b/Common/processcurrent.cpp
index 2f84738..923ff62 100644
--- a/Common/processcurrent.cpp
+++ b/Common/processcurrent.cpp
@@ -20,9 +20,9 @@
 #include "FDTD/engine_interface_fdtd.h"
 #include <iomanip>
 
-ProcessCurrent::ProcessCurrent(Operator_Base* op) : ProcessIntegral(op)
+ProcessCurrent::ProcessCurrent(Engine_Interface_Base* eng_if) : ProcessIntegral(eng_if)
 {
-	m_TimeShift = op->GetTimestep()/2.0;
+	m_TimeShift = Op->GetTimestep()/2.0;
 	m_dualMesh = true;
 }
 
diff --git a/Common/processcurrent.h b/Common/processcurrent.h
index 224eeca..e382fb5 100644
--- a/Common/processcurrent.h
+++ b/Common/processcurrent.h
@@ -23,7 +23,7 @@
 class ProcessCurrent : public ProcessIntegral
 {
 public:
-	ProcessCurrent(Operator_Base* op);
+	ProcessCurrent(Engine_Interface_Base* eng_if);
 	virtual ~ProcessCurrent();
 
 	//! Integrate currents flowing through an area
diff --git a/Common/processfields.cpp b/Common/processfields.cpp
index 957d507..38a7eb4 100644
--- a/Common/processfields.cpp
+++ b/Common/processfields.cpp
@@ -21,7 +21,7 @@
 #include "processfields.h"
 #include "FDTD/engine_interface_fdtd.h"
 
-ProcessFields::ProcessFields(Operator_Base* op) : Processing(op)
+ProcessFields::ProcessFields(Engine_Interface_Base* eng_if) : Processing(eng_if)
 {
 	m_DumpType = E_FIELD_DUMP;
 	// vtk-file is default
diff --git a/Common/processfields.h b/Common/processfields.h
index 22321fc..914c881 100644
--- a/Common/processfields.h
+++ b/Common/processfields.h
@@ -26,7 +26,7 @@
 class ProcessFields : public Processing
 {
 public:
-	ProcessFields(Operator_Base* op);
+	ProcessFields(Engine_Interface_Base* eng_if);
 	virtual ~ProcessFields();
 
 	enum FileType { VTK_FILETYPE, HDF5_FILETYPE};
diff --git a/Common/processfields_td.cpp b/Common/processfields_td.cpp
index af4560f..da41136 100644
--- a/Common/processfields_td.cpp
+++ b/Common/processfields_td.cpp
@@ -21,7 +21,7 @@
 #include <sstream>
 #include <string>
 
-ProcessFieldsTD::ProcessFieldsTD(Operator_Base* op) : ProcessFields(op)
+ProcessFieldsTD::ProcessFieldsTD(Engine_Interface_Base* eng_if) : ProcessFields(eng_if)
 {
 	pad_length = 8;
 }
diff --git a/Common/processfields_td.h b/Common/processfields_td.h
index cc57ca1..e30b748 100644
--- a/Common/processfields_td.h
+++ b/Common/processfields_td.h
@@ -23,7 +23,7 @@
 class ProcessFieldsTD : public ProcessFields
 {
 public:
-	ProcessFieldsTD(Operator_Base* op);
+	ProcessFieldsTD(Engine_Interface_Base* eng_if);
 	virtual ~ProcessFieldsTD();
 
 	virtual int Process();
diff --git a/Common/processing.cpp b/Common/processing.cpp
index 251baf9..b249894 100644
--- a/Common/processing.cpp
+++ b/Common/processing.cpp
@@ -23,9 +23,11 @@
 #include "time.h"
 #include <climits>
 
-Processing::Processing(Operator_Base* op)
+Processing::Processing(Engine_Interface_Base* eng_if)
 {
-	Op=op;
+	m_Eng_Interface = NULL;
+	SetEngineInterface(eng_if);
+
 	Enabled = true;
 	m_PS_pos = 0;
 	SetPrecision(12);
@@ -36,7 +38,6 @@ Processing::Processing(Operator_Base* op)
 	m_Flush = false;
 	m_dualMesh = false;
 	m_Mesh_Type = CARTESIAN_MESH;
-	m_Eng_Interface = NULL;
 }
 
 Processing::~Processing()
@@ -54,6 +55,10 @@ void Processing::SetEngineInterface(Engine_Interface_Base* eng_if)
 {
 	delete m_Eng_Interface;
 	m_Eng_Interface = eng_if;
+	if (m_Eng_Interface)
+		Op=m_Eng_Interface->GetOperator();
+	else
+		Op=NULL;
 }
 
 bool Processing::CheckTimestep()
diff --git a/Common/processing.h b/Common/processing.h
index 9faa538..e25851b 100644
--- a/Common/processing.h
+++ b/Common/processing.h
@@ -40,7 +40,7 @@ using namespace std;
 class Processing
 {
 public:
-	Processing(Operator_Base* op);
+	Processing(Engine_Interface_Base* eng_if);
 	virtual ~Processing();
 
 	enum MeshType { CARTESIAN_MESH, CYLINDRICAL_MESH};
@@ -91,7 +91,7 @@ public:
 
 protected:
 	Engine_Interface_Base* m_Eng_Interface;
-	Operator_Base* Op;
+	const Operator_Base* Op;
 	MeshType m_Mesh_Type;
 
 	unsigned int m_precision;
diff --git a/Common/processintegral.cpp b/Common/processintegral.cpp
index 94d8c7b..deeb926 100644
--- a/Common/processintegral.cpp
+++ b/Common/processintegral.cpp
@@ -18,7 +18,7 @@
 #include "processintegral.h"
 #include <iomanip>
 
-ProcessIntegral::ProcessIntegral(Operator_Base* op)  : Processing(op)
+ProcessIntegral::ProcessIntegral(Engine_Interface_Base* eng_if)  : Processing(eng_if)
 {
 	m_TimeShift = 0.0;
 	m_Results=NULL;
diff --git a/Common/processintegral.h b/Common/processintegral.h
index 5a43372..c6fda5e 100644
--- a/Common/processintegral.h
+++ b/Common/processintegral.h
@@ -51,7 +51,7 @@ public:
 	virtual int Process();
 
 protected:
-	ProcessIntegral(Operator_Base* op);
+	ProcessIntegral(Engine_Interface_Base* eng_if);
 
 	//! timeshift to be used in TD and FD data, e.g. 0.5*dT in case of current based parameter
 	double m_TimeShift;
diff --git a/Common/processmodematch.cpp b/Common/processmodematch.cpp
index 805d8d0..feb9034 100644
--- a/Common/processmodematch.cpp
+++ b/Common/processmodematch.cpp
@@ -20,7 +20,7 @@
 #include "Common/operator_base.h"
 #include "tools/array_ops.h"
 
-ProcessModeMatch::ProcessModeMatch(Operator_Base* op) : ProcessIntegral(op)
+ProcessModeMatch::ProcessModeMatch(Engine_Interface_Base* eng_if) : ProcessIntegral(eng_if)
 {
 	for (int n=0; n<2; ++n)
 	{
diff --git a/Common/processmodematch.h b/Common/processmodematch.h
index 9f19726..1e0c45f 100644
--- a/Common/processmodematch.h
+++ b/Common/processmodematch.h
@@ -30,7 +30,7 @@ class CSFunctionParser;
 class ProcessModeMatch : public ProcessIntegral
 {
 public:
-	ProcessModeMatch(Operator_Base* op);
+	ProcessModeMatch(Engine_Interface_Base* eng_if);
 	virtual ~ProcessModeMatch();
 
 	virtual void InitProcess();
diff --git a/Common/processvoltage.cpp b/Common/processvoltage.cpp
index 8d94b6b..b593af7 100644
--- a/Common/processvoltage.cpp
+++ b/Common/processvoltage.cpp
@@ -18,7 +18,7 @@
 #include "processvoltage.h"
 #include <iomanip>
 
-ProcessVoltage::ProcessVoltage(Operator_Base* op) : ProcessIntegral(op)
+ProcessVoltage::ProcessVoltage(Engine_Interface_Base* eng_if) : ProcessIntegral(eng_if)
 {
 }
 
diff --git a/Common/processvoltage.h b/Common/processvoltage.h
index 91768ce..f00e7de 100644
--- a/Common/processvoltage.h
+++ b/Common/processvoltage.h
@@ -24,7 +24,7 @@
 class ProcessVoltage : public ProcessIntegral
 {
 public:
-	ProcessVoltage(Operator_Base* op);
+	ProcessVoltage(Engine_Interface_Base* eng_if);
 	virtual ~ProcessVoltage();
 
 	virtual double CalcIntegral();
diff --git a/FDTD/engine_interface_fdtd.cpp b/FDTD/engine_interface_fdtd.cpp
index a01c4e1..d787fad 100644
--- a/FDTD/engine_interface_fdtd.cpp
+++ b/FDTD/engine_interface_fdtd.cpp
@@ -17,16 +17,10 @@
 
 #include "engine_interface_fdtd.h"
 
-Engine_Interface_FDTD::Engine_Interface_FDTD() : Engine_Interface_Base()
+Engine_Interface_FDTD::Engine_Interface_FDTD(Operator* op, Engine* eng) : Engine_Interface_Base(op)
 {
-	m_Op = NULL;
-	m_Eng = NULL;
-}
-
-Engine_Interface_FDTD::Engine_Interface_FDTD(Operator* op, Engine* eng) : Engine_Interface_Base()
-{
-	SetOperator(op);
-	SetEngine(eng);
+	m_Op = op;
+	m_Eng = eng;
 }
 
 Engine_Interface_FDTD::~Engine_Interface_FDTD()
diff --git a/FDTD/engine_interface_fdtd.h b/FDTD/engine_interface_fdtd.h
index f5118ca..0151ece 100644
--- a/FDTD/engine_interface_fdtd.h
+++ b/FDTD/engine_interface_fdtd.h
@@ -27,14 +27,13 @@
 class Engine_Interface_FDTD : public Engine_Interface_Base
 {
 public:
-	Engine_Interface_FDTD();
 	Engine_Interface_FDTD(Operator* op, Engine* eng);
 	virtual ~Engine_Interface_FDTD();
 
 	//! Set the FDTD operator
-	virtual void SetOperator(Operator* op) {m_Op=op;}
+	virtual void SetFDTDOperator(Operator* op) {SetOperator(op); m_Op=op;}
 	//! Set the FDTD engine
-	virtual void SetEngine(Engine* eng) {m_Eng=eng;}
+	virtual void SetFDTDEngine(Engine* eng) {m_Eng=eng;}
 
 	//! Get the FDTD engine in case direct access is needed. Direct access is not recommended!
 	const Engine* GetFDTDEngine() const {return m_Eng;}
diff --git a/openems.cpp b/openems.cpp
index 6c11439..9d44726 100644
--- a/openems.cpp
+++ b/openems.cpp
@@ -460,21 +460,21 @@ int openEMS::SetupFDTD(const char* file)
 			{
 				if (pb->GetProbeType()==0)
 				{
-					ProcessVoltage* procVolt = new ProcessVoltage(FDTD_Op);
+					ProcessVoltage* procVolt = new ProcessVoltage(new Engine_Interface_FDTD(FDTD_Op,FDTD_Eng));
 					proc=procVolt;
 				}
 				else if (pb->GetProbeType()==1)
 				{
-					ProcessCurrent* procCurr = new ProcessCurrent(FDTD_Op);
+					ProcessCurrent* procCurr = new ProcessCurrent(new Engine_Interface_FDTD(FDTD_Op,FDTD_Eng));
 					proc=procCurr;
 				}
 				else if (pb->GetProbeType()==2)
-					proc = new ProcessEField(FDTD_Op,FDTD_Eng);
+					proc = new ProcessEField(new Engine_Interface_FDTD(FDTD_Op,FDTD_Eng),FDTD_Eng);
 				else if (pb->GetProbeType()==3)
-					proc = new ProcessHField(FDTD_Op,FDTD_Eng);
+					proc = new ProcessHField(new Engine_Interface_FDTD(FDTD_Op,FDTD_Eng),FDTD_Eng);
 				else if ((pb->GetProbeType()==10) || (pb->GetProbeType()==11))
 				{
-					ProcessModeMatch* pmm = new ProcessModeMatch(FDTD_Op);
+					ProcessModeMatch* pmm = new ProcessModeMatch(new Engine_Interface_FDTD(FDTD_Op,FDTD_Eng));
 					pmm->SetFieldType(pb->GetProbeType()-10);
 					pmm->SetModeFunction(0,pb->GetAttributeValue("ModeFunctionX"));
 					pmm->SetModeFunction(1,pb->GetAttributeValue("ModeFunctionY"));
@@ -488,7 +488,6 @@ int openEMS::SetupFDTD(const char* file)
 				}
 				if (CylinderCoords)
 					proc->SetMeshType(Processing::CYLINDRICAL_MESH);
-				proc->SetEngineInterface(new Engine_Interface_FDTD(FDTD_Op,FDTD_Eng));
 				proc->SetProcessInterval(Nyquist/m_OverSampling);
 				proc->AddFrequency(pb->GetFDSamples());
 				proc->SetName(pb->GetName());
@@ -506,7 +505,7 @@ int openEMS::SetupFDTD(const char* file)
 	vector<CSProperties*> DumpProps = CSX.GetPropertyByType(CSProperties::DUMPBOX);
 	for (size_t i=0; i<DumpProps.size(); ++i)
 	{
-		ProcessFieldsTD* ProcTD = new ProcessFieldsTD(FDTD_Op);
+		ProcessFieldsTD* ProcTD = new ProcessFieldsTD(new Engine_Interface_FDTD(FDTD_Op,FDTD_Eng));
 		ProcTD->SetEnable(Enable_Dumps);
 		ProcTD->SetProcessInterval(Nyquist/m_OverSampling);
 
@@ -528,7 +527,6 @@ int openEMS::SetupFDTD(const char* file)
 			CSPropDumpBox* db = DumpProps.at(i)->ToDumpBox();
 			if (db)
 			{
-				ProcTD->SetEngineInterface(new Engine_Interface_FDTD(FDTD_Op,FDTD_Eng));
 				ProcTD->SetDumpType((ProcessFields::DumpType)db->GetDumpType());
 				ProcTD->SetDumpMode((Engine_Interface_Base::InterpolationType)db->GetDumpMode());
 				ProcTD->SetFileType((ProcessFields::FileType)db->GetFileType());
@@ -598,8 +596,7 @@ void openEMS::RunFDTD()
 	cout << "Running FDTD engine... this may take a while... grab a cup of coffee?!?" << endl;
 
 	//special handling of a field processing, needed to realize the end criteria...
-	ProcessFields* ProcField = new ProcessFields(FDTD_Op);
-	ProcField->SetEngineInterface(new Engine_Interface_FDTD(FDTD_Op,FDTD_Eng));
+	ProcessFields* ProcField = new ProcessFields(new Engine_Interface_FDTD(FDTD_Op,FDTD_Eng));
 	PA->AddProcessing(ProcField);
 	double maxE=0,currE=0;