caiyu/openEMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

processing constructor with Engine_Interface_Base only

Browse Source 
Signed-off-by: Thorsten Liebig <Thorsten.Liebig@gmx.de>
This commit is contained in:
Thorsten Liebig 2010-12-07 16:47:23 +01:00
parent 57ead21ccc
commit 043ec7c1a1
23 changed files with 51 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Common/engine_interface_base.cpp
View File

@ -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;
}

11
Common/engine_interface_base.h
View File

@ -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;
};

2
Common/process_efield.cpp
View File

@ -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;
}

2
Common/process_efield.h
View File

@ -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();

2
Common/process_hfield.cpp
View File

@ -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)
{
}

2
Common/process_hfield.h
View File

@ -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();

4
Common/processcurrent.cpp
View File

@ -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;
}

2
Common/processcurrent.h
View File

@ -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

2
Common/processfields.cpp
View File

@ -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

2
Common/processfields.h
View File

@ -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};

2
Common/processfields_td.cpp
View File

@ -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;
}

2
Common/processfields_td.h
View File

@ -23,7 +23,7 @@
class ProcessFieldsTD : public ProcessFields
{
public:
ProcessFieldsTD(Operator_Base* op);
ProcessFieldsTD(Engine_Interface_Base* eng_if);
virtual ~ProcessFieldsTD();
virtual int Process();

11
Common/processing.cpp
View File

@ -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()

4
Common/processing.h
View File

@ -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;

2
Common/processintegral.cpp
View File

@ -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;

2
Common/processintegral.h
View File

@ -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;

2
Common/processmodematch.cpp
View File

@ -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)
{

2
Common/processmodematch.h
View File

@ -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();

2
Common/processvoltage.cpp
View File

@ -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)
{
}

2
Common/processvoltage.h
View File

@ -24,7 +24,7 @@
class ProcessVoltage : public ProcessIntegral
{
public:
ProcessVoltage(Operator_Base* op);
ProcessVoltage(Engine_Interface_Base* eng_if);
virtual ~ProcessVoltage();
virtual double CalcIntegral();

12
FDTD/engine_interface_fdtd.cpp
View File

@ -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()

5
FDTD/engine_interface_fdtd.h
View File

@ -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;}

17
openems.cpp
View File

@ -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;