openEMS/FDTD/engine_cylindermultigrid.cpp

/*
*	Copyright (C) 2010 Thorsten Liebig (Thorsten.Liebig@gmx.de)
*
*	This program is free software: you can redistribute it and/or modify
*	it under the terms of the GNU General Public License as published by
*	the Free Software Foundation, either version 3 of the License, or
*	(at your option) any later version.
*
*	This program is distributed in the hope that it will be useful,
*	but WITHOUT ANY WARRANTY; without even the implied warranty of
*	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*	GNU General Public License for more details.
*
*	You should have received a copy of the GNU General Public License
*	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "engine_cylindermultigrid.h"
#include "operator_cylindermultigrid.h"
#include "engine_ext_cylindermultigrid.h"

Engine_CylinderMultiGrid* Engine_CylinderMultiGrid::New(const Operator_CylinderMultiGrid* op, unsigned int numThreads)
{
	cout << "Create FDTD engine (cylindrical multi grid mesh using sse compression + multithreading)" << endl;
	Engine_CylinderMultiGrid* e = new Engine_CylinderMultiGrid(op);
	e->setNumThreads( numThreads );
	e->Init();
	return e;
}

Engine_CylinderMultiGrid::Engine_CylinderMultiGrid(const Operator_CylinderMultiGrid* op) : Engine_Multithread(op)
{
	Op_CMG = op;

	m_WaitOnBase = new boost::barrier(2);
	m_WaitOnChild = new boost::barrier(2);
	m_WaitOnSync = new boost::barrier(2);

	Engine* eng = op->GetInnerOperator()->CreateEngine();
	m_InnerEngine = dynamic_cast<Engine_Multithread*>(eng);

	m_Eng_Ext_MG = new Engine_Ext_CylinderMultiGrid(NULL,true);
	m_Eng_Ext_MG->SetBarrier(m_WaitOnBase, m_WaitOnChild, m_WaitOnSync);
	m_Eng_Ext_MG->SetEngine(this);
	m_InnerEng_Ext_MG = new Engine_Ext_CylinderMultiGrid(NULL,false);
	m_InnerEng_Ext_MG->SetBarrier(m_WaitOnBase, m_WaitOnChild, m_WaitOnSync);

	m_InnerEngine->m_Eng_exts.push_back(m_InnerEng_Ext_MG);
}

Engine_CylinderMultiGrid::~Engine_CylinderMultiGrid()
{
	m_Thread_NumTS = 0;
	m_startBarrier->wait();

	m_IteratorThread_Group.join_all();

	delete m_InnerEngine;
	m_InnerEngine = NULL;

	delete m_WaitOnBase;
	m_WaitOnBase = NULL;
	delete m_WaitOnChild;
	m_WaitOnChild = NULL;
	delete m_WaitOnSync;
	m_WaitOnSync = NULL;

	delete m_startBarrier;
	m_startBarrier = NULL;
	delete m_stopBarrier;
	m_stopBarrier = NULL;

}

void Engine_CylinderMultiGrid::Init()
{
	Engine_Multithread::Init();

	m_Eng_exts.push_back(m_Eng_Ext_MG);

	m_startBarrier = new boost::barrier(3); //both engines + organizer
	m_stopBarrier = new boost::barrier(3); //both engines + organizer

	boost::thread *t = NULL;

	t = new boost::thread( Engine_CylinderMultiGrid_Thread(this,m_startBarrier,m_stopBarrier,&m_Thread_NumTS) );
	m_IteratorThread_Group.add_thread( t );

	t = new boost::thread( Engine_CylinderMultiGrid_Thread(m_InnerEngine,m_startBarrier,m_stopBarrier,&m_Thread_NumTS) );
	m_IteratorThread_Group.add_thread( t );
}

bool Engine_CylinderMultiGrid::IterateTS(unsigned int iterTS)
{
	m_Thread_NumTS = iterTS;

	m_startBarrier->wait(); //start base and child iterations

	m_stopBarrier->wait();  //tell base and child to wait for another start event...

	//interpolate child data to base mesh...
	for (unsigned int n=0;n<Op_CMG->m_Split_Pos-1;++n)
		InterpolVoltChild2Base(n);
	for (unsigned int n=0;n<Op_CMG->m_Split_Pos-2;++n)
		InterpolCurrChild2Base(n);

	return true;
}

void Engine_CylinderMultiGrid::InitExtensions()
{
	m_InnerEngine->InitExtensions();
	Engine_Multithread::InitExtensions();
}

void Engine_CylinderMultiGrid::InterpolVoltChild2Base(unsigned int rzPlane)
{
	//interpolate voltages from child engine to the base engine...
	unsigned int pos[3];
	unsigned int pos1_rz1, pos1_rz2;
	unsigned int pos1_a1, pos1_a2;
	pos[0] = rzPlane;
	bool isOdd, isEven;
	f4vector half, one_eighth, three_eighth;
	for (int n=0;n<4;++n)
	{
		half.f[n]=0.5;
		one_eighth.f[n]   = 1.0/8.0;
		three_eighth.f[n] = 3.0/8.0;
	}
	for (pos[1]=0; pos[1]<numLines[1]; ++pos[1])
	{
		isOdd = (pos[1]%2);
		isEven = !isOdd * (pos[1]>0);

		pos1_rz1 = pos[1]/2;
		pos1_rz2 = pos[1]/2 + isOdd;

		pos1_rz1 += pos[1]==1;
		pos1_rz2 -= pos[1]==(numLines[1]-2);

		pos1_a1 = pos[1]/2;
		pos1_a2 = pos[1]/2 + isOdd - isEven;
		pos1_a2 += pos[1]==(numLines[1]-1);
		pos1_a2 -= pos[1]==(numLines[1]-2);

		for (pos[2]=0; pos[2]<numVectors; ++pos[2])
		{
			//r - direction
			f4_volt[0][pos[0]][pos[1]][pos[2]].v = half.v * ( m_InnerEngine->f4_volt[0][pos[0]][pos1_rz1][pos[2]].v + m_InnerEngine->f4_volt[0][pos[0]][pos1_rz2][pos[2]].v);

			//z - direction
			f4_volt[2][pos[0]][pos[1]][pos[2]].v = half.v * ( m_InnerEngine->f4_volt[2][pos[0]][pos1_rz1][pos[2]].v + m_InnerEngine->f4_volt[2][pos[0]][pos1_rz2][pos[2]].v);

			//alpha - direction
			f4_volt[1][pos[0]][pos[1]][pos[2]].v  = three_eighth.v * m_InnerEngine->f4_volt[1][pos[0]][pos1_a1][pos[2]].v;
			f4_volt[1][pos[0]][pos[1]][pos[2]].v += one_eighth.v * m_InnerEngine->f4_volt[1][pos[0]][pos1_a2][pos[2]].v;
		}
	}

	//r,z - interpolation correction...
	pos[1]=1;
	for (pos[2]=0; pos[2]<numVectors; ++pos[2])
	{
		f4_volt[0][pos[0]][pos[1]][pos[2]].v  += half.v * (m_InnerEngine->f4_volt[0][pos[0]][1][pos[2]].v - m_InnerEngine->f4_volt[0][pos[0]][2][pos[2]].v);
		f4_volt[2][pos[0]][pos[1]][pos[2]].v  += half.v * (m_InnerEngine->f4_volt[2][pos[0]][1][pos[2]].v - m_InnerEngine->f4_volt[2][pos[0]][2][pos[2]].v);
	}
	pos[1]=numLines[1]-2;
	for (pos[2]=0; pos[2]<numVectors; ++pos[2])
	{
		f4_volt[0][pos[0]][pos[1]][pos[2]].v  += half.v * (m_InnerEngine->f4_volt[0][pos[0]][pos[1]/2][pos[2]].v - m_InnerEngine->f4_volt[0][pos[0]][pos[1]/2-1][pos[2]].v);
		f4_volt[2][pos[0]][pos[1]][pos[2]].v  += half.v * (m_InnerEngine->f4_volt[2][pos[0]][pos[1]/2][pos[2]].v - m_InnerEngine->f4_volt[2][pos[0]][pos[1]/2-1][pos[2]].v);
	}
}

void Engine_CylinderMultiGrid::InterpolCurrChild2Base(unsigned int rzPlane)
{
	//interpolate voltages from child engine to the base engine...
	unsigned int pos[3];
	unsigned int pos1_rz1, pos1_rz2;
	unsigned int pos1_a1, pos1_a2;
	pos[0] = rzPlane;
	bool isOdd, isEven;
	f4vector quarter, one_fourth, three_fourth;
	for (int n=0;n<4;++n)
	{
		quarter.f[n]=0.25;
		one_fourth.f[n] = 1.0/4.0;
		three_fourth.f[n] = 3.0/4.0;
	}
	for (pos[1]=0; pos[1]<numLines[1]; ++pos[1])
	{
		isOdd = (pos[1]%2);
		isEven = !isOdd * (pos[1]>0);

		pos1_a1 = pos[1]/2;
		pos1_a2 = pos[1]/2 + isOdd;

		pos1_a1 += pos[1]==1;
		pos1_a2 -= pos[1]==(numLines[1]-2);

		pos1_rz1 = pos[1]/2;
		pos1_rz2 = pos[1]/2 + isOdd - isEven;
		pos1_rz2 += pos[1]==(numLines[1]-1);
		pos1_rz2 -= pos[1]==(numLines[1]-2);

		for (pos[2]=0; pos[2]<numVectors; ++pos[2])
		{
			//r - direction
			f4_curr[0][pos[0]][pos[1]][pos[2]].v  = three_fourth.v * m_InnerEngine->f4_curr[0][pos[0]][pos1_rz1][pos[2]].v;
			f4_curr[0][pos[0]][pos[1]][pos[2]].v += one_fourth.v * m_InnerEngine->f4_curr[0][pos[0]][pos1_rz2][pos[2]].v;

			//z - direction
			f4_curr[2][pos[0]][pos[1]][pos[2]].v  = three_fourth.v * m_InnerEngine->f4_curr[2][pos[0]][pos1_rz1][pos[2]].v;
			f4_curr[2][pos[0]][pos[1]][pos[2]].v += one_fourth.v * m_InnerEngine->f4_curr[2][pos[0]][pos1_rz2][pos[2]].v;

			//alpha - direction
			f4_curr[1][pos[0]][pos[1]][pos[2]].v  = quarter.v * (m_InnerEngine->f4_curr[1][pos[0]][pos1_a1][pos[2]].v + m_InnerEngine->f4_curr[1][pos[0]][pos1_a2][pos[2]].v);
		}

	}
	//alpha - interpolation correction...
	pos[1]=1;
	for (pos[2]=0; pos[2]<numVectors; ++pos[2])
		f4_curr[1][pos[0]][pos[1]][pos[2]].v  += quarter.v * (m_InnerEngine->f4_curr[1][pos[0]][1][pos[2]].v - m_InnerEngine->f4_curr[1][pos[0]][2][pos[2]].v);
	pos[1]=numLines[1]-2;
	for (pos[2]=0; pos[2]<numVectors; ++pos[2])
		f4_curr[1][pos[0]][pos[1]][pos[2]].v  += quarter.v * (m_InnerEngine->f4_curr[1][pos[0]][pos[1]/2][pos[2]].v - m_InnerEngine->f4_curr[1][pos[0]][pos[1]/2-1][pos[2]].v);
}

/****************************************************************************************/
Engine_CylinderMultiGrid_Thread::Engine_CylinderMultiGrid_Thread( Engine_Multithread* engine, boost::barrier *start, boost::barrier *stop, volatile unsigned int* numTS)
{
	m_startBarrier = start;
	m_stopBarrier = stop;
	m_Eng=engine;
	m_numTS = numTS;
}

void Engine_CylinderMultiGrid_Thread::operator()()
{
	m_startBarrier->wait(); //wait for Base engine to start the iterations...

	while(*m_numTS>0)	//m_numTS==0 request to terminate this thread...
	{
		m_Eng->Engine_Multithread::IterateTS(*m_numTS);
		m_stopBarrier->wait();		//sync all workers after iterations are performed
		m_startBarrier->wait();		//wait for Base engine to start the iterations again ...
	}
}