mx/src/getErrors.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 "gridFunctionNorms.h"
#include "besselPrimeZeros.h"
#include "besselZeros.h"

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

Macros
#define	exmax   EXTERN_C_NAME(exmax)
#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	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	UG(i0, i1, i2, i3)   ugp[i0+ugDim0*(i1+ugDim1*(i2+ugDim2*(i3)))]
#define	ERR(i0, i1, i2, i3)   errep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*(i3)))]
#define	U(i0, i1, i2, i3)   uep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*(i3)))]
#define	ERR(i0, i1, i2, i3)   errep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*(i3)))]
#define	U(i0, i1, i2, i3)   uep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*(i3)))]

Functions
void	exmax (double &Ez, double &Bx, double &By, const int &nsources, const double &xs, const double &ys, const double &tau, const double &var, const double &amp, const double &a, const double &x, const double &y, const double &time)
void	computeDSIErrors (Maxwell &mx, MappedGrid &mg, realArray &uh, realArray &uhp, realArray &ue, realArray &uep, realArray &errh, realArray &erre, RealArray &solutionNorm, RealArray &maximumError)
	local function to compute errors for the staggered grid DSI schemes

Macro Definition Documentation

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

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

#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 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 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 exmax   EXTERN_C_NAME(exmax)

#define EXTGFP_SENTINEL

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

Referenced by Maxwell::getErrors().

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

Referenced by Maxwell::getErrors().

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

Referenced by Maxwell::getErrors().

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

Referenced by Maxwell::getErrors().

#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]

Referenced by Maxwell::getErrors().

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

Referenced by Maxwell::getErrors().

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

Referenced by Maxwell::getErrors().

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

Referenced by Maxwell::getErrors().

#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]

Referenced by Maxwell::getErrors().

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

Referenced by Maxwell::getErrors().

#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 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]

Referenced by Maxwell::getErrors().

#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]

Referenced by Maxwell::getErrors().

#define hzGaussianPulse

(

xi

)

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

Referenced by Maxwell::getErrors().

#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]

Referenced by Maxwell::getErrors().

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

Referenced by Maxwell::getErrors().

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

Referenced by Maxwell::getErrors().

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

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

#define U	(		i0,
			i1,
			i2,
			i3
	)		uep[i0+ueDim0*(i1+ueDim1*(i2+ueDim2*(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 UG	(		i0,
			i1,
			i2,
			i3
	)		ugp[i0+ugDim0*(i1+ugDim1*(i2+ugDim2*(i3)))]

#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 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 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 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)))]

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

Function Documentation

void computeDSIErrors	(	Maxwell &	mx,
		MappedGrid &	mg,
		realArray &	uh,
		realArray &	uhp,
		realArray &	ue,
		realArray &	uep,
		realArray &	errh,
		realArray &	erre,
		RealArray &	solutionNorm,
		RealArray &	maximumError
	)

local function to compute errors for the staggered grid DSI schemes

References assert(), c, Maxwell::divEMax, e, erre, errh, f, Maxwell::gradEMax, off(), ue, uep, uh, and uhp.

Referenced by Maxwell::getErrors().

void exmax	(	double &	Ez,
		double &	Bx,
		double &	By,
		const int &	nsources,
		const double &	xs,
		const double &	ys,
		const double &	tau,
		const double &	var,
		const double &	amp,
		const double &	a,
		const double &	x,
		const double &	y,
		const double &	time
	)