real norm_diff(scalar *a, scalar *b, int n)
{
real bmag = 0.0, diffmag = 0.0;
int i;
for (i = 0; i < n; ++i) {
scalar d;
ASSIGN_SCALAR(d,
SCALAR_RE(b[i]) - SCALAR_RE(a[i]),
SCALAR_IM(b[i]) - SCALAR_IM(a[i]));
bmag += SCALAR_NORMSQR(b[i]);
diffmag += SCALAR_NORMSQR(d);
}
return sqrt(diffmag / bmag);
}
/* Compute the parity of all of the states in X, returning an array
of the parities (which the caller should deallocate with free).
The parity of an arbitrary state is defined as the expectation value
of the mirror flip operator, and will be +1/-1 for even/odd eigenstates
and something in between for everything else. Assumes that the
columns of X are normalized to 1. */
double *maxwell_yparity(evectmatrix X, maxwell_data *d)
{
int i, j, k, b, nx, ny, nz;
double *yparity, *yp_scratch, *norm_scratch;
CHECK(d, "null maxwell data pointer!");
CHECK(X.c == 2, "fields don't have 2 components!");
CHK_MALLOC(yparity, double, X.p);
CHK_MALLOC(yp_scratch, double, X.p);
for (b = 0; b < X.p; ++b)
yp_scratch[b] = 0.0;
CHK_MALLOC(norm_scratch, double, X.p);
for (b = 0; b < X.p; ++b)
norm_scratch[b] = 0.0;
nx = d->local_nx;
ny = d->ny;
nz = d->nz;
for (i = 0; i < nx; ++i) {
for (j = 0; 2*j <= ny; ++j) {
int ij = i * ny + j;
int ij2 = i * ny + (j > 0 ? ny - j : 0);
for (k = 0; k < nz; ++k) {
int ijk = ij * nz + k;
int ijk2 = ij2 * nz + k;
for (b = 0; b < X.p; ++b) {
scalar u,v, u2,v2;
u = X.data[(ijk * 2) * X.p + b];
v = X.data[(ijk * 2 + 1) * X.p + b];
u2 = X.data[(ijk2 * 2) * X.p + b];
v2 = X.data[(ijk2 * 2 + 1) * X.p + b];
yp_scratch[b] += (ijk == ijk2 ? 1.0 : 2.0) *
(SCALAR_RE(v) * SCALAR_RE(v2) +
SCALAR_IM(v) * SCALAR_IM(v2) -
SCALAR_RE(u) * SCALAR_RE(u2) -
SCALAR_IM(u) * SCALAR_IM(u2));
norm_scratch[b] += (ijk == ijk2 ? 1.0 : 2.0) *
(SCALAR_RE(v) * SCALAR_RE(v) +
SCALAR_IM(v) * SCALAR_IM(v) +
SCALAR_RE(u) * SCALAR_RE(u) +
SCALAR_IM(u) * SCALAR_IM(u));
}
}
}
}
mpi_allreduce(yp_scratch, yparity, X.p,
double, MPI_DOUBLE, MPI_SUM, mpb_comm);
mpi_allreduce(norm_scratch, yp_scratch, X.p,
double, MPI_DOUBLE, MPI_SUM, mpb_comm);
for (b = 0; b < X.p; ++b)
yparity[b] /= yp_scratch[b];
free(yp_scratch);
free(norm_scratch);
return yparity;
}
/* Compute the parity of all of the states in X, returning an array
of the parities (which the caller should deallocate with free).
The parity of an arbitrary state is defined as the expectation value
of the mirror flip operator, and will be +1/-1 for even/odd eigenstates
and something in between for everything else. Assumes that the
columns of X are normalized to 1. */
double *maxwell_zparity(evectmatrix X, maxwell_data *d)
{
int i, j, b, nxy, nz;
double *zparity, *zp_scratch, *norm_scratch;
CHECK(d, "null maxwell data pointer!");
CHECK(X.c == 2, "fields don't have 2 components!");
CHK_MALLOC(zparity, double, X.p);
CHK_MALLOC(zp_scratch, double, X.p);
for (b = 0; b < X.p; ++b)
zp_scratch[b] = 0.0;
CHK_MALLOC(norm_scratch, double, X.p);
for (b = 0; b < X.p; ++b)
norm_scratch[b] = 0.0;
if (d->nz > 1) {
nxy = d->other_dims;
nz = d->last_dim;
}
else {
nxy = d->other_dims * d->last_dim;
nz = 1;
}
for (i = 0; i < nxy; ++i)
for (j = 0; 2*j <= nz; ++j) {
int ij = i * nz + j;
int ij2 = i * nz + (j > 0 ? nz - j : 0);
for (b = 0; b < X.p; ++b) {
scalar u,v, u2,v2;
u = X.data[(ij * 2) * X.p + b];
v = X.data[(ij * 2 + 1) * X.p + b];
u2 = X.data[(ij2 * 2) * X.p + b];
v2 = X.data[(ij2 * 2 + 1) * X.p + b];
zp_scratch[b] += (ij == ij2 ? 1.0 : 2.0) *
(SCALAR_RE(u) * SCALAR_RE(u2) +
SCALAR_IM(u) * SCALAR_IM(u2) -
SCALAR_RE(v) * SCALAR_RE(v2) -
SCALAR_IM(v) * SCALAR_IM(v2));
norm_scratch[b] += (ij == ij2 ? 1.0 : 2.0) *
(SCALAR_RE(u) * SCALAR_RE(u) +
SCALAR_IM(u) * SCALAR_IM(u) +
SCALAR_RE(v) * SCALAR_RE(v) +
SCALAR_IM(v) * SCALAR_IM(v));
}
}
mpi_allreduce(zp_scratch, zparity, X.p,
double, MPI_DOUBLE, MPI_SUM, mpb_comm);
mpi_allreduce(norm_scratch, zp_scratch, X.p,
double, MPI_DOUBLE, MPI_SUM, mpb_comm);
for (b = 0; b < X.p; ++b)
zparity[b] /= zp_scratch[b];
free(zp_scratch);
free(norm_scratch);
return zparity;
}
/* Project X to its even or odd component, so that we can solve
for only one parity of states (the projection operator, like the
mirror flip operator, commutes with the Maxwell operator, so this
projection should not slow convergence). */
void maxwell_zparity_constraint(evectmatrix X, void *data)
{
maxwell_data *d = (maxwell_data *) data;
int i, j, b, nxy, nz;
int zparity = ((d->parity & EVEN_Z_PARITY) ? +1 :
((d->parity & ODD_Z_PARITY) ? -1 : 0));
if (zparity == 0)
return;
CHECK(d, "null maxwell data pointer!");
CHECK(X.c == 2, "fields don't have 2 components!");
if (d->nz > 1) {
nxy = d->other_dims;
nz = d->last_dim;
}
else { /* common case (2d system): even/odd == TE/TM */
nxy = d->other_dims * d->last_dim;
if (zparity == +1)
for (i = 0; i < nxy; ++i)
for (b = 0; b < X.p; ++b) {
ASSIGN_ZERO(X.data[(i * X.c + 1) * X.p + b]);
}
else if (zparity == -1)
for (i = 0; i < nxy; ++i)
for (b = 0; b < X.p; ++b) {
ASSIGN_ZERO(X.data[(i * X.c) * X.p + b]);
}
return;
}
for (i = 0; i < nxy; ++i) {
for (j = 0; 2*j <= nz; ++j) {
int ij = i * nz + j;
int ij2 = i * nz + (j > 0 ? nz - j : 0);
for (b = 0; b < X.p; ++b) {
scalar u,v, u2,v2;
u = X.data[(ij * 2) * X.p + b];
v = X.data[(ij * 2 + 1) * X.p + b];
u2 = X.data[(ij2 * 2) * X.p + b];
v2 = X.data[(ij2 * 2 + 1) * X.p + b];
ASSIGN_SCALAR(X.data[(ij * 2) * X.p + b],
0.5*(SCALAR_RE(u) + zparity*SCALAR_RE(u2)),
0.5*(SCALAR_IM(u) + zparity*SCALAR_IM(u2)));
ASSIGN_SCALAR(X.data[(ij * 2 + 1) * X.p + b],
0.5*(SCALAR_RE(v) - zparity*SCALAR_RE(v2)),
0.5*(SCALAR_IM(v) - zparity*SCALAR_IM(v2)));
ASSIGN_SCALAR(X.data[(ij2 * 2) * X.p + b],
0.5*(SCALAR_RE(u2) + zparity*SCALAR_RE(u)),
0.5*(SCALAR_IM(u2) + zparity*SCALAR_IM(u)));
ASSIGN_SCALAR(X.data[(ij2 * 2 + 1) * X.p + b],
0.5*(SCALAR_RE(v2) - zparity*SCALAR_RE(v)),
0.5*(SCALAR_IM(v2) - zparity*SCALAR_IM(v)));
}
}
}
}
cnumber sqmatrix_ref(SCM mo, integer i, integer j)
{
sqmatrix *m = assert_sqmatrix_smob(mo);
cnumber c;
CHECK(m && i >= 0 && j >= 0 && i < m->p && j < m->p,
"invalid arguments to sqmatrix-ref");
c.re = SCALAR_RE(m->data[i * m->p + j]);
c.im = SCALAR_IM(m->data[i * m->p + j]);
return c;
}
/* Project X to its even or odd component, so that we can solve
for only one parity of states (the projection operator, like the
mirror flip operator, commutes with the Maxwell operator, so this
projection should not slow convergence). */
void maxwell_yparity_constraint(evectmatrix X, void *data)
{
maxwell_data *d = (maxwell_data *) data;
int i, j, k, b, nx, ny, nz;
int yparity = ((d->parity & EVEN_Y_PARITY) ? +1 :
((d->parity & ODD_Y_PARITY) ? -1 : 0));
if (yparity == 0)
return;
CHECK(d, "null maxwell data pointer!");
CHECK(X.c == 2, "fields don't have 2 components!");
nx = d->local_nx;
ny = d->ny;
nz = d->nz;
for (i = 0; i < nx; ++i) {
for (j = 0; 2*j <= ny; ++j) {
int ij = i * ny + j;
int ij2 = i * ny + (j > 0 ? ny - j : 0);
for (k = 0; k < nz; ++k) {
int ijk = ij * nz + k;
int ijk2 = ij2 * nz + k;
for (b = 0; b < X.p; ++b) {
scalar u,v, u2,v2;
u = X.data[(ijk * 2) * X.p + b];
v = X.data[(ijk * 2 + 1) * X.p + b];
u2 = X.data[(ijk2 * 2) * X.p + b];
v2 = X.data[(ijk2 * 2 + 1) * X.p + b];
ASSIGN_SCALAR(X.data[(ijk * 2) * X.p + b],
0.5*(SCALAR_RE(u) - yparity*SCALAR_RE(u2)),
0.5*(SCALAR_IM(u) - yparity*SCALAR_IM(u2)));
ASSIGN_SCALAR(X.data[(ijk * 2 + 1) * X.p + b],
0.5*(SCALAR_RE(v) + yparity*SCALAR_RE(v2)),
0.5*(SCALAR_IM(v) + yparity*SCALAR_IM(v2)));
ASSIGN_SCALAR(X.data[(ijk2 * 2) * X.p + b],
0.5*(SCALAR_RE(u2) - yparity*SCALAR_RE(u)),
0.5*(SCALAR_IM(u2) - yparity*SCALAR_IM(u)));
ASSIGN_SCALAR(X.data[(ijk2 * 2 + 1) * X.p + b],
0.5*(SCALAR_RE(v2) + yparity*SCALAR_RE(v)),
0.5*(SCALAR_IM(v2) + yparity*SCALAR_IM(v)));
}
}
}
}
}
