/* 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)));
}
}
}
}
/* during eigensolution (for upper bands), their DC components are
constrained to be zero */
void maxwell_zero_k_constraint(evectmatrix X, void *data)
{
int j;
if (X.Nstart > 0)
return; /* DC frequency is not on this process */
for (j = 0; j < X.p; ++j) {
ASSIGN_ZERO(X.data[j]);
ASSIGN_ZERO(X.data[X.p + j]);
}
(void)data; /* avoid warning about unused parameter */
}
void blasglue_herk(char uplo, char trans, int n, int k,
real a, scalar *A, int fdA,
real b, scalar *C, int fdC)
{
if (n == 0)
return;
if (k == 0) {
int i, j;
for (i = 0; i < n; ++i)
for (j = 0; j < n; ++j)
ASSIGN_ZERO(C[i*fdC + j]);
return;
}
CHECK(A != C, "herk output array must be distinct");
uplo = uplo == 'U' ? 'L' : 'U';
trans = (trans == 'C' || trans == 'T') ? 'N' : 'C';
#ifdef SCALAR_COMPLEX
F(herk,HERK) (&uplo, &trans, &n, &k,
&a, A, &fdA, &b, C, &fdC);
#else
F(syrk,SYRK) (&uplo, &trans, &n, &k,
&a, A, &fdA, &b, C, &fdC);
#endif
}
void blasglue_gemm(char transa, char transb, int m, int n, int k,
real a, scalar *A, int fdA, scalar *B, int fdB,
real b, scalar *C, int fdC)
{
scalar alpha, beta;
if (m*n == 0)
return;
if (k == 0) {
int i, j;
for (i = 0; i < m; ++i)
for (j = 0; j < n; ++j)
ASSIGN_ZERO(C[i*fdC + j]);
return;
}
CHECK(A != C && B != C, "gemm output array must be distinct");
ASSIGN_REAL(alpha,a);
ASSIGN_REAL(beta,b);
F(gemm,GEMM) (&transb, &transa, &n, &m, &k,
&alpha, B, &fdB, A, &fdA, &beta, C, &fdC);
}
void maxwell_zero_k_set_const_bands(evectmatrix X, maxwell_data *d)
{
int i, j, num_const_bands, m_band = 1, n_band = 1;
CHECK(d, "null maxwell data pointer!");
CHECK(X.c == 2, "fields don't have 2 components!");
if (X.p < 1)
return;
num_const_bands = maxwell_zero_k_num_const_bands(X, d);
/* Initialize num_const_bands to zero: */
for (i = 0; i < X.n; ++i)
for (j = 0; j < num_const_bands; ++j) {
ASSIGN_ZERO(X.data[i * X.p + j]);
}
if (X.Nstart > 0)
return; /* DC frequency is not on this process */
/* Set DC components to 1 (in two parities) for num_const_bands: */
if (d->parity & (ODD_Z_PARITY | EVEN_Y_PARITY))
m_band = 0;
if (d->parity & (ODD_Y_PARITY | EVEN_Z_PARITY))
n_band = 0;
if (m_band) {
ASSIGN_SCALAR(X.data[0], 1.0, 0.0);
ASSIGN_SCALAR(X.data[X.p], 0.0, 0.0);
}
if (n_band && (!m_band || X.p >= 2)) {
ASSIGN_SCALAR(X.data[m_band], 0.0, 0.0);
ASSIGN_SCALAR(X.data[X.p + m_band], 1.0, 0.0);
}
}
