// TFSF boundaries
Field TFSF(Field EM, Loss lass, Loss1d lass1d, double Cour){
int dx, dy;
// TFSF boundary
Bound first, last;
first.x = 10; last.x = 390;
first.y = 10; last.y = 190;
// Update along right
dx = last.x;
for (int dy = first.y; dy <= last.y; dy++){
EM.Hz(dx, dy) -= lass.HzE(dx, dy) * EM.Ey1d[dx];
}
// Updating Hz along left
dx = first.x - 1;
for (int dy = first.y; dy <= last.y; dy++){
EM.Hz(dx, dy) += lass.HzE(dx, dy) * EM.Ey1d[dx + 1];
}
// Insert 1d grid stuff here. Update magnetic and electric field
Hupdate1d(EM, lass1d, EM.t);
Eupdate1d(EM, lass1d, EM.t);
//EM.Ey1d[10] = ricker(EM.t,0, Cour);
EM.Ey1d[10] = planewave(EM.t, 15, Cour, 30, 40);
EM.t++;
std::cout << EM.t << '\n';
// Check mag instead of ricker.
// Update along right edge!
dx = last.x;
for (int dy = first.y; dy <= last.y; dy++){
EM.Ey(dx,dy) -= lass.EyH(dx, dy) * EM.Hz1d[dx];
}
// Updating along left edge
dx = first.x;
for (int dy = first.y; dy <= last.y; dy++){
EM.Ey(dx,dy) += lass.EyH(dx, dy) * EM.Hz1d[dx-1];
}
// Updating along top
dy = last.y;
for (int dx = first.x; dx <= last.x; dx++){
EM.Ex(dx,dy) += lass.ExH(dx, dy) * EM.Hz1d[dx];
}
// Update along bot
dy = first.y;
for (int dx = first.x; dx <= last.x; dx++){
EM.Ex(dx,dy) -= lass.ExH(dx, dy) * EM.Hz1d[dx];
}
return EM;
}
// 2 dimensional functions for E / H movement
Field Hupdate2d(Field EM, Loss lass, int t){
// update magnetic field, x direction
for (size_t dx = 0; dx < spacex - 1; dx++){
for (size_t dy = 0; dy < spacey - 1; dy++){
EM.Hz(dx,dy) = lass.HzH(dx,dy) * EM.Hz(dx, dy)
+ lass.HzE(dx,dy) * ((EM.Ex(dx, dy + 1)
- EM.Ex(dx, dy))
- (EM.Ey(dx + 1,dy)
- EM.Ey(dx, dy)));
}
}
return EM;
}
Field Eupdate2d(Field EM, Loss lass, int t){
// update electric field
for (size_t dx = 0; dx < spacex - 1; dx++){
for (size_t dy = 1; dy < spacey - 1; dy++){
EM.Ex(dx,dy) = lass.ExE(dx,dy) * EM.Ex(dx,dy)
+ lass.ExH(dx,dy) * (EM.Hz(dx, dy) - EM.Hz(dx, dy - 1));
}
}
for (size_t dx = 1; dx < spacex - 1; dx++){
for (size_t dy = 0; dy < spacey - 1; dy++){
EM.Ey(dx,dy) = lass.EyE(dx,dy) * EM.Ey(dx,dy)
- lass.EyH(dx,dy) * (EM.Hz(dx, dy) - EM.Hz(dx - 1, dy));
}
}
return EM;
}
// This is the function we writs the bulk of the code in
void FDTD(Field EM,
const int final_time, const double eps,
std::ofstream& output){
double loss = 0.00;
double Cour = 1 / sqrt(2);
Loss lass;
lass = createloss2d(lass, eps, Cour, loss);
Loss1d lass1d;
lass1d = createloss1d(lass1d, eps, Cour, loss);
// Time looping
for (int t = 0; t < final_time; t++){
EM = Hupdate2d(EM, lass, t);
EM = TFSF(EM, lass, lass1d, Cour);
EM = Eupdate2d(EM,lass,t);
EM = ABCcheck(EM, lass);
// EM.Ey(200,100) = ricker(t, 0, Cour);
// Outputting to a file
int check = 5;
if (t % check == 0){
for (int dx = 0; dx < spacex; dx = dx++){
for (int dy = 0; dy < spacey; dy = dy++){
output << t << '\t' << dx <<'\t' << dy << '\t'
<< EM.Hz(dx, dy) << '\t' << EM.Ey(dx, dy)
<< '\t' << EM.Ex(dx, dy) << '\t' << '\n';
}
}
output << '\n' << '\n';
}
}
}
// Checking Absorbing Boundary Conditions (ABC)
Field ABCcheck(Field EM, Loss lass){
// defining constant for ABC
double c1, c2, c3, temp1, temp2;
temp1 = sqrt(lass.ExH(0,0) * lass.HzE(0,0));
temp2 = 1.0 / temp1 + 2.0 + temp1;
c1 = -(1.0 / temp1 - 2.0 + temp1) / temp2;
c2 = -2.0 * (temp1 - 1.0 / temp1) / temp2;
c3 = 4.0 * (temp1 + 1.0 / temp1) / temp2;
size_t dx, dy;
// Setting ABC for top
for (dx = 0; dx < spacex; dx++){
EM.Ex(dx, spacey - 1) = c1 * (EM.Ex(dx, spacey - 3) + EM.Etop(0, 1, dx))
+ c2 * (EM.Etop(0, 0, dx) + EM.Etop(2, 0 , dx)
-EM.Ex(dx,spacey - 2) -EM.Etop(1, 1, dx))
+ c3 * EM.Etop(1, 0, dx) - EM.Etop(2, 1, dx);
// memorizing fields...
for (dy = 0; dy < 3; dy++){
EM.Etop(dy, 1, dx) = EM.Etop(dy, 0, dx);
EM.Etop(dy, 0, dx) = EM.Ex(dx, spacey - 1 - dy);
}
}
// Setting ABC for bottom
for (dx = 0; dx < spacex; dx++){
EM.Ex(dx,0) = c1 * (EM.Ex(dx, 2) + EM.Ebot(0, 1, dx))
+ c2 * (EM.Ebot(0, 0, dx) + EM.Ebot(2, 0 , dx)
-EM.Ex(dx,1) -EM.Ebot(1, 1, dx))
+ c3 * EM.Ebot(1, 0, dx) - EM.Ebot(2, 1, dx);
// memorizing fields...
for (dy = 0; dy < 3; dy++){
EM.Ebot(dy, 1, dx) = EM.Ebot(dy, 0, dx);
EM.Ebot(dy, 0, dx) = EM.Ex(dx, dy);
}
}
// ABC on right
for (dy = 0; dy < spacey; dy++){
EM.Ey(spacex - 1,dy) = c1 * (EM.Ey(spacex - 3,dy) + EM.Eright(0, 1, dy))
+ c2 * (EM.Eright(0, 0, dy) + EM.Eright(2, 0 , dy)
-EM.Ey(spacex - 2,dy) -EM.Eright(1, 1, dy))
+ c3 * EM.Eright(1, 0, dy) - EM.Eright(2, 1, dy);
// memorizing fields...
for (dx = 0; dx < 3; dx++){
EM.Eright(dx, 1, dy) = EM.Eright(dx, 0, dy);
EM.Eright(dx, 0, dy) = EM.Ey(spacex - 1 - dx, dy);
}
}
// Setting ABC for left side of grid. Woo!
for (dy = 0; dy < spacey; dy++){
EM.Ey(0,dy) = c1 * (EM.Ey(2,dy) + EM.Eleft(0, 1, dy))
+ c2 * (EM.Eleft(0, 0, dy) + EM.Eleft(2, 0 , dy)
-EM.Ey(1,dy) -EM.Eleft(1, 1, dy))
+ c3 * EM.Eleft(1, 0, dy) - EM.Eleft(2, 1, dy);
// memorizing fields...
for (dx = 0; dx < 3; dx++){
EM.Eleft(dx, 1, dy) = EM.Eleft(dx, 0, dy);
EM.Eleft(dx, 0, dy) = EM.Ey(dx, dy);
}
}
return EM;
}
