mx/src/forcing.C File Reference

#include "Maxwell.h"
#include "CompositeGridOperators.h"
#include "display.h"
#include "UnstructuredMapping.h"
#include "OGPolyFunction.h"
#include "OGTrigFunction.h"
#include "OGPulseFunction.h"
#include "interpPoints.h"
#include "ShowFileReader.h"
#include "ParallelUtility.h"
#include "App.h"

Include dependency graph for mx/src/forcing.C:

Macros
#define	forcingOptMaxwell   EXTERN_C_NAME(forcingoptmaxwell)
#define	FOR_3D(i1, i2, i3, I1, I2, I3)   int I1Base =I1.getBase(), I2Base =I2.getBase(), I3Base =I3.getBase(); int I1Bound=I1.getBound(), I2Bound=I2.getBound(), I3Bound=I3.getBound(); for(i3=I3Base; i3<=I3Bound; i3++) for(i2=I2Base; i2<=I2Bound; i2++) for(i1=I1Base; i1<=I1Bound; i1++)
#define	FOR_3(i1, i2, i3, I1, I2, I3)   I1Base =I1.getBase(), I2Base =I2.getBase(), I3Base =I3.getBase(); I1Bound=I1.getBound(), I2Bound=I2.getBound(), I3Bound=I3.getBound(); for(i3=I3Base; i3<=I3Bound; i3++) for(i2=I2Base; i2<=I2Bound; i2++) for(i1=I1Base; i1<=I1Bound; i1++)
#define	exTrue(x, y, t)   sin(twoPi*(kx*(x)+ky*(y)-cc*(t)))*pwc[0]
#define	eyTrue(x, y, t)   sin(twoPi*(kx*(x)+ky*(y)-cc*(t)))*pwc[1]
#define	hzTrue(x, y, t)   sin(twoPi*(kx*(x)+ky*(y)-cc*(t)))*pwc[5]
#define	extTrue(x, y, t)   (-twoPi*cc)*cos(twoPi*(kx*(x)+ky*(y)-cc*(t)))*pwc[0]
#define	eytTrue(x, y, t)   (-twoPi*cc)*cos(twoPi*(kx*(x)+ky*(y)-cc*(t)))*pwc[1]
#define	hztTrue(x, y, t)   (-twoPi*cc)*cos(twoPi*(kx*(x)+ky*(y)-cc*(t)))*pwc[5]
#define	exLaplacianTrue(x, y, t)   sin(twoPi*(kx*(x)+ky*(y)-cc*(t)))*(-(twoPi*twoPi*(kx*kx+ky*ky))*pwc[0])
#define	eyLaplacianTrue(x, y, t)   sin(twoPi*(kx*(x)+ky*(y)-cc*(t)))*(-(twoPi*twoPi*(kx*kx+ky*ky))*pwc[1])
#define	hzLaplacianTrue(x, y, t)   sin(twoPi*(kx*(x)+ky*(y)-cc*(t)))*(-(twoPi*twoPi*(kx*kx+ky*ky))*pwc[5])
#define	hzGaussianPulse(xi)   exp(-betaGaussianPlaneWave*((xi)*(xi)))
#define	exGaussianPulse(xi)   hzGaussianPulse(xi)*(-ky/(eps*cc))
#define	eyGaussianPulse(xi)   hzGaussianPulse(xi)*( kx/(eps*cc))
#define	hzLaplacianGaussianPulse(xi)   ((4.*betaGaussianPlaneWave*betaGaussianPlaneWave*(kx*kx+ky*ky))*xi*xi-(2.*betaGaussianPlaneWave*(kx*kx+ky*ky)))*exp(-betaGaussianPlaneWave*((xi)*(xi)))
#define	exLaplacianGaussianPulse(xi)   hzLaplacianGaussianPulse(xi,t)*(-ky/(eps*cc))
#define	eyLaplacianGaussianPulse(xi)   hzLaplacianGaussianPulse(xi,t)*( kx/(eps*cc))
#define	exTrue3d(x, y, z, t)   sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*pwc[0]
#define	eyTrue3d(x, y, z, t)   sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*pwc[1]
#define	ezTrue3d(x, y, z, t)   sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*pwc[2]
#define	extTrue3d(x, y, z, t)   (-twoPi*cc)*cos(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*pwc[0]
#define	eytTrue3d(x, y, z, t)   (-twoPi*cc)*cos(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*pwc[1]
#define	eztTrue3d(x, y, z, t)   (-twoPi*cc)*cos(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*pwc[2]
#define	hxTrue3d(x, y, z, t)   sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*pwc[3]
#define	hyTrue3d(x, y, z, t)   sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*pwc[4]
#define	hzTrue3d(x, y, z, t)   sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*pwc[5]
#define	exLaplacianTrue3d(x, y, z, t)   sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*(-(twoPi*twoPi*(kx*kx+ky*ky+kz*kz))*pwc[0])
#define	eyLaplacianTrue3d(x, y, z, t)   sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*(-(twoPi*twoPi*(kx*kx+ky*ky+kz*kz))*pwc[1])
#define	ezLaplacianTrue3d(x, y, z, t)   sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*(-(twoPi*twoPi*(kx*kx+ky*ky+kz*kz))*pwc[2])
#define	hxLaplacianTrue3d(x, y, z, t)   sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*(-(twoPi*twoPi*(kx*kx+ky*ky+kz*kz))*pwc[3])
#define	hyLaplacianTrue3d(x, y, z, t)   sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*(-(twoPi*twoPi*(kx*kx+ky*ky+kz*kz))*pwc[4])
#define	hzLaplacianTrue3d(x, y, z, t)   sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*(-(twoPi*twoPi*(kx*kx+ky*ky+kz*kz))*pwc[5])
#define	EXTGFP_SENTINEL
#define	UHX(i0, i1, i2)   uhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hx )))]
#define	UHY(i0, i1, i2)   uhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hy )))]
#define	UHZ(i0, i1, i2)   uhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hz )))]
#define	UMHX(i0, i1, i2)   umhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hx )))]
#define	UMHY(i0, i1, i2)   umhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hy )))]
#define	UMHZ(i0, i1, i2)   umhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hz )))]
#define	UNHX(i0, i1, i2)   unhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hx )))]
#define	UNHY(i0, i1, i2)   unhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hy )))]
#define	UNHZ(i0, i1, i2)   unhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hz )))]
#define	ERRHX(i0, i1, i2)   errhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hx )))]
#define	ERRHY(i0, i1, i2)   errhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hy )))]
#define	ERRHZ(i0, i1, i2)   errhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hz )))]
#define	XHP(i0, i1, i2, i3)   xhp[i0+xhDim0*(i1+xhDim1*(i2+xhDim2*(i3)))]
#define	X(i0, i1, i2, i3)   xhp[i0+xhDim0*(i1+xhDim1*(i2+xhDim2*(i3)))]
#define	UEX(i0, i1, i2)   uep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ex )))]
#define	UEY(i0, i1, i2)   uep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ey )))]
#define	UEZ(i0, i1, i2)   uep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ez )))]
#define	UMEX(i0, i1, i2)   umep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ex )))]
#define	UMEY(i0, i1, i2)   umep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ey )))]
#define	UMEZ(i0, i1, i2)   umep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ez )))]
#define	UNEX(i0, i1, i2)   unep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ex )))]
#define	UNEY(i0, i1, i2)   unep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ey )))]
#define	UNEZ(i0, i1, i2)   unep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ez )))]
#define	ERREX(i0, i1, i2)   errep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ex )))]
#define	ERREY(i0, i1, i2)   errep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ey )))]
#define	ERREZ(i0, i1, i2)   errep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ez )))]
#define	MASK(i0, i1, i2)   maskp[(i0)+(i1)*md1+(i2)*md2]
#define	XEP(i0, i1, i2, i3)   xep[i0+xeDim0*(i1+xeDim1*(i2+xeDim2*(i3)))]
#define	U(i0, i1, i2, i3)   up[i0+uDim0*(i1+uDim1*(i2+uDim2*(i3)))]
#define	CC   ex
#define	CC   ey
#define	CC   hz
#define	CC   ex
#define	CC   ey
#define	CC   hz
#define	CC   ex
#define	CC   ey
#define	CC   ez
#define	CC   ex
#define	CC   ey
#define	CC   ez
#define	CC   hx
#define	CC   hy
#define	CC   hz
#define	CC   ex
#define	CC   ey
#define	CC   hz
#define	CC   ex
#define	CC   ey
#define	CC   hz
#define	CC   ex
#define	CC   ey
#define	CC   ez
#define	CC   ex
#define	CC   ey
#define	CC   ez
#define	CC   hx
#define	CC   hy
#define	CC   hz
#define	CC   ex
#define	CC   ey
#define	CC   hz
#define	CC   ex
#define	CC   ey
#define	CC   ez
#define	CC   ex
#define	CC   ey
#define	CC   hz
#define	CC   ex
#define	CC   ey
#define	CC   ez
#define	X0(i0, i1, i2)   (xa+dx0*(i0-i0a))
#define	X1(i0, i1, i2)   (ya+dy0*(i1-i1a))
#define	X2(i0, i1, i2)   (za+dz0*(i2-i2a))

Functions
void	forcingOptMaxwell (const int &nd, const int &nd1a, const int &nd1b, const int &nd2a, const int &nd2b, const int &nd3a, const int &nd3b, const int &ndf1a, const int &ndf1b, const int &ndf2a, const int &ndf2b, const int &ndf3a, const int &ndf3b, real &u, const real &f, const int &mask, const real &rx, const real &x, const int &ipar, const real &rpar, int &ierr)
real	ogf_ (OGFunction *&ep, const real &x, const real &y, const real &z, const int &c, const real &t)
void	ogf2d_ (OGFunction *&ep, const real &x, const real &y, const real &t, real &u, real &v, real &w)
void	ogderiv_ (OGFunction *&ep, const int &ntd, const int &nxd, const int &nyd, const int &nzd, const real &x, const real &y, const real &z, const real &t, const int &n, real &ud)
void	ogderiv3_ (OGFunction *&ep, const int &ntd, const int &nxd, const int &nyd, const int &nzd, const real &x, const real &y, const real &z, const real &t, const int &n1, real &ud1, const int &n2, real &ud2, const int &n3, real &ud3)
void	ogf3d_ (OGFunction *&ep, const real &x, const real &y, const real &z, const real &t, real &u, real &v, real &w)
real	exx_ (OGFunction *&ep, const real &x, const real &y, const real &z, const int &c, const real &t)

Macro Definition Documentation

#define CC   ex

Referenced by Maxwell::getForcing().

#define CC   ey

#define CC   hz

#define CC   ex

#define CC   ey

#define CC   hz

#define CC   ex

#define CC   ey

#define CC   ez

#define CC   ex

#define CC   ey

#define CC   ez

#define CC   hx

#define CC   hy

#define CC   hz

#define CC   ex

#define CC   ey

#define CC   hz

#define CC   ex

#define CC   ey

#define CC   hz

#define CC   ex

#define CC   ey

#define CC   ez

#define CC   ex

#define CC   ey

#define CC   ez

#define CC   hx

#define CC   hy

#define CC   hz

#define CC   ex

#define CC   ey

#define CC   hz

#define CC   ex

#define CC   ey

#define CC   ez

#define CC   ex

#define CC   ey

#define CC   hz

#define CC   ex

#define CC   ey

#define CC   ez

#define ERREX	(		i0,
			i1,
			i2
	)		errep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ex )))]

Referenced by FOR_3D(), Maxwell::getErrors(), and if().

#define ERREY	(		i0,
			i1,
			i2
	)		errep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ey )))]

Referenced by FOR_3D(), Maxwell::getErrors(), and if().

#define ERREZ	(		i0,
			i1,
			i2
	)		errep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ez )))]

Referenced by FOR_3D(), Maxwell::getErrors(), and if().

#define ERRHX	(		i0,
			i1,
			i2
	)		errhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hx )))]

Referenced by Maxwell::getErrors().

#define ERRHY	(		i0,
			i1,
			i2
	)		errhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hy )))]

Referenced by Maxwell::getErrors().

#define ERRHZ	(		i0,
			i1,
			i2
	)		errhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hz )))]

Referenced by Maxwell::getErrors(), and if().

#define exGaussianPulse

(

xi

)

hzGaussianPulse(xi)*(-ky/(eps*cc))

#define exLaplacianGaussianPulse

(

xi

)

hzLaplacianGaussianPulse(xi,t)*(-ky/(eps*cc))

#define exLaplacianTrue	(		x,
			y,
			t
	)		sin(twoPi*(kx*(x)+ky*(y)-cc*(t)))*(-(twoPi*twoPi*(kx*kx+ky*ky))*pwc[0])

#define exLaplacianTrue3d	(		x,
			y,
			z,
			t
	)		sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*(-(twoPi*twoPi*(kx*kx+ky*ky+kz*kz))*pwc[0])

#define EXTGFP_SENTINEL

#define exTrue	(		x,
			y,
			t
	)		sin(twoPi*(kx*(x)+ky*(y)-cc*(t)))*pwc[0]

#define exTrue3d	(		x,
			y,
			z,
			t
	)		sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*pwc[0]

#define extTrue	(		x,
			y,
			t
	)		(-twoPi*cc)*cos(twoPi*(kx*(x)+ky*(y)-cc*(t)))*pwc[0]

#define extTrue3d	(		x,
			y,
			z,
			t
	)		(-twoPi*cc)*cos(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*pwc[0]

#define eyGaussianPulse

(

xi

)

hzGaussianPulse(xi)*( kx/(eps*cc))

#define eyLaplacianGaussianPulse

(

xi

)

hzLaplacianGaussianPulse(xi,t)*( kx/(eps*cc))

#define eyLaplacianTrue	(		x,
			y,
			t
	)		sin(twoPi*(kx*(x)+ky*(y)-cc*(t)))*(-(twoPi*twoPi*(kx*kx+ky*ky))*pwc[1])

#define eyLaplacianTrue3d	(		x,
			y,
			z,
			t
	)		sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*(-(twoPi*twoPi*(kx*kx+ky*ky+kz*kz))*pwc[1])

#define eyTrue	(		x,
			y,
			t
	)		sin(twoPi*(kx*(x)+ky*(y)-cc*(t)))*pwc[1]

#define eyTrue3d	(		x,
			y,
			z,
			t
	)		sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*pwc[1]

#define eytTrue	(		x,
			y,
			t
	)		(-twoPi*cc)*cos(twoPi*(kx*(x)+ky*(y)-cc*(t)))*pwc[1]

#define eytTrue3d	(		x,
			y,
			z,
			t
	)		(-twoPi*cc)*cos(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*pwc[1]

#define ezLaplacianTrue3d	(		x,
			y,
			z,
			t
	)		sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*(-(twoPi*twoPi*(kx*kx+ky*ky+kz*kz))*pwc[2])

#define ezTrue3d	(		x,
			y,
			z,
			t
	)		sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*pwc[2]

#define eztTrue3d	(		x,
			y,
			z,
			t
	)		(-twoPi*cc)*cos(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*pwc[2]

#define FOR_3	(		i1,
			i2,
			i3,
			I1,
			I2,
			I3
	)		I1Base =I1.getBase(), I2Base =I2.getBase(), I3Base =I3.getBase(); I1Bound=I1.getBound(), I2Bound=I2.getBound(), I3Bound=I3.getBound(); for(i3=I3Base; i3<=I3Bound; i3++) for(i2=I2Base; i2<=I2Bound; i2++) for(i1=I1Base; i1<=I1Bound; i1++)

#define FOR_3D	(		i1,
			i2,
			i3,
			I1,
			I2,
			I3
	)		int I1Base =I1.getBase(), I2Base =I2.getBase(), I3Base =I3.getBase(); int I1Bound=I1.getBound(), I2Bound=I2.getBound(), I3Bound=I3.getBound(); for(i3=I3Base; i3<=I3Bound; i3++) for(i2=I2Base; i2<=I2Bound; i2++) for(i1=I1Base; i1<=I1Bound; i1++)

#define forcingOptMaxwell   EXTERN_C_NAME(forcingoptmaxwell)

Referenced by Maxwell::getForcing().

#define hxLaplacianTrue3d	(		x,
			y,
			z,
			t
	)		sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*(-(twoPi*twoPi*(kx*kx+ky*ky+kz*kz))*pwc[3])

#define hxTrue3d	(		x,
			y,
			z,
			t
	)		sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*pwc[3]

#define hyLaplacianTrue3d	(		x,
			y,
			z,
			t
	)		sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*(-(twoPi*twoPi*(kx*kx+ky*ky+kz*kz))*pwc[4])

#define hyTrue3d	(		x,
			y,
			z,
			t
	)		sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*pwc[4]

#define hzGaussianPulse

(

xi

)

exp(-betaGaussianPlaneWave*((xi)*(xi)))

#define hzLaplacianGaussianPulse

(

xi

)

((4.*betaGaussianPlaneWave*betaGaussianPlaneWave*(kx*kx+ky*ky))*xi*xi-(2.*betaGaussianPlaneWave*(kx*kx+ky*ky)))*exp(-betaGaussianPlaneWave*((xi)*(xi)))

#define hzLaplacianTrue	(		x,
			y,
			t
	)		sin(twoPi*(kx*(x)+ky*(y)-cc*(t)))*(-(twoPi*twoPi*(kx*kx+ky*ky))*pwc[5])

#define hzLaplacianTrue3d	(		x,
			y,
			z,
			t
	)		sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*(-(twoPi*twoPi*(kx*kx+ky*ky+kz*kz))*pwc[5])

#define hzTrue	(		x,
			y,
			t
	)		sin(twoPi*(kx*(x)+ky*(y)-cc*(t)))*pwc[5]

#define hzTrue3d	(		x,
			y,
			z,
			t
	)		sin(twoPi*(kx*(x)+ky*(y)+kz*(z)-cc*(t)))*pwc[5]

#define hztTrue	(		x,
			y,
			t
	)		(-twoPi*cc)*cos(twoPi*(kx*(x)+ky*(y)-cc*(t)))*pwc[5]

#define MASK	(		i0,
			i1,
			i2
	)		maskp[(i0)+(i1)*md1+(i2)*md2]

#define U	(		i0,
			i1,
			i2,
			i3
	)		up[i0+uDim0*(i1+uDim1*(i2+uDim2*(i3)))]

#define UEX	(		i0,
			i1,
			i2
	)		uep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ex )))]

Referenced by Maxwell::assignInitialConditions(), FOR_3D(), Maxwell::getErrors(), and if().

#define UEY	(		i0,
			i1,
			i2
	)		uep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ey )))]

Referenced by Maxwell::assignInitialConditions(), FOR_3D(), Maxwell::getErrors(), and if().

#define UEZ	(		i0,
			i1,
			i2
	)		uep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ez )))]

Referenced by Maxwell::assignInitialConditions(), FOR_3D(), Maxwell::getErrors(), and if().

#define UHX	(		i0,
			i1,
			i2
	)		uhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hx )))]

Referenced by Maxwell::assignInitialConditions(), FOR_3(), and Maxwell::getErrors().

#define UHY	(		i0,
			i1,
			i2
	)		uhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hy )))]

Referenced by Maxwell::assignInitialConditions(), FOR_3(), and Maxwell::getErrors().

#define UHZ	(		i0,
			i1,
			i2
	)		uhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hz )))]

Referenced by Maxwell::assignInitialConditions(), FOR_3(), Maxwell::getErrors(), and if().

#define UMEX	(		i0,
			i1,
			i2
	)		umep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ex )))]

Referenced by Maxwell::assignInitialConditions(), FOR_3D(), and if().

#define UMEY	(		i0,
			i1,
			i2
	)		umep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ey )))]

Referenced by Maxwell::assignInitialConditions(), FOR_3D(), and if().

#define UMEZ	(		i0,
			i1,
			i2
	)		umep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ez )))]

Referenced by Maxwell::assignInitialConditions(), FOR_3D(), and if().

#define UMHX	(		i0,
			i1,
			i2
	)		umhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hx )))]

Referenced by Maxwell::assignInitialConditions(), and FOR_3().

#define UMHY	(		i0,
			i1,
			i2
	)		umhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hy )))]

Referenced by Maxwell::assignInitialConditions(), and FOR_3().

#define UMHZ	(		i0,
			i1,
			i2
	)		umhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hz )))]

Referenced by Maxwell::assignInitialConditions(), FOR_3(), and if().

#define UNEX	(		i0,
			i1,
			i2
	)		unep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ex )))]

#define UNEY	(		i0,
			i1,
			i2
	)		unep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ey )))]

#define UNEZ	(		i0,
			i1,
			i2
	)		unep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*( ez )))]

#define UNHX	(		i0,
			i1,
			i2
	)		unhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hx )))]

#define UNHY	(		i0,
			i1,
			i2
	)		unhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hy )))]

#define UNHZ	(		i0,
			i1,
			i2
	)		unhp[i0+uhDim0*(i1+uhDim1*(i2+uhDim2*( hz )))]

#define X	(		i0,
			i1,
			i2,
			i3
	)		xhp[i0+xhDim0*(i1+xhDim1*(i2+xhDim2*(i3)))]

#define X0	(		i0,
			i1,
			i2
	)		(xa+dx0*(i0-i0a))

#define X1	(		i0,
			i1,
			i2
	)		(ya+dy0*(i1-i1a))

#define X2	(		i0,
			i1,
			i2
	)		(za+dz0*(i2-i2a))

#define XEP	(		i0,
			i1,
			i2,
			i3
	)		xep[i0+xeDim0*(i1+xeDim1*(i2+xeDim2*(i3)))]

Referenced by Maxwell::assignInitialConditions(), FOR_3D(), Maxwell::getErrors(), Maxwell::getForcing(), and if().

#define XHP	(		i0,
			i1,
			i2,
			i3
	)		xhp[i0+xhDim0*(i1+xhDim1*(i2+xhDim2*(i3)))]

Referenced by Maxwell::assignInitialConditions(), FOR_3(), Maxwell::getErrors(), Maxwell::getForcing(), and if().

Function Documentation

real exx_	(	OGFunction *&	ep,
		const real &	x,
		const real &	y,
		const real &	z,
		const int &	c,
		const real &	t
	)

void forcingOptMaxwell	(	const int &	nd,
		const int &	nd1a,
		const int &	nd1b,
		const int &	nd2a,
		const int &	nd2b,
		const int &	nd3a,
		const int &	nd3b,
		const int &	ndf1a,
		const int &	ndf1b,
		const int &	ndf2a,
		const int &	ndf2b,
		const int &	ndf3a,
		const int &	ndf3b,
		real &	u,
		const real &	f,
		const int &	mask,
		const real &	rx,
		const real &	x,
		const int &	ipar,
		const real &	rpar,
		int &	ierr
	)

void ogderiv3_	(	OGFunction *&	ep,
		const int &	ntd,
		const int &	nxd,
		const int &	nyd,
		const int &	nzd,
		const real &	x,
		const real &	y,
		const real &	z,
		const real &	t,
		const int &	n1,
		real &	ud1,
		const int &	n2,
		real &	ud2,
		const int &	n3,
		real &	ud3
	)

void ogderiv_	(	OGFunction *&	ep,
		const int &	ntd,
		const int &	nxd,
		const int &	nyd,
		const int &	nzd,
		const real &	x,
		const real &	y,
		const real &	z,
		const real &	t,
		const int &	n,
		real &	ud
	)

void ogf2d_	(	OGFunction *&	ep,
		const real &	x,
		const real &	y,
		const real &	t,
		real &	u,
		real &	v,
		real &	w
	)

References x, and y.

void ogf3d_	(	OGFunction *&	ep,
		const real &	x,
		const real &	y,
		const real &	z,
		const real &	t,
		real &	u,
		real &	v,
		real &	w
	)

References x, y, and z.

real ogf_	(	OGFunction *&	ep,
		const real &	x,
		const real &	y,
		const real &	z,
		const int &	c,
		const real &	t
	)

References x, y, and z.