maxwell_interface.cpp

#include "maxwell_interface.h"

namespace maxwell {

void
field::zero()
{
    Ex = vecxd::Zero(num_dofs);
    Ey = vecxd::Zero(num_dofs);
    Ez = vecxd::Zero(num_dofs);
    Hx = vecxd::Zero(num_dofs);
    Hy = vecxd::Zero(num_dofs);
    Hz = vecxd::Zero(num_dofs);
}

void
field::resize(size_t p_num_dofs)
{
    Ex = vecxd::Zero(p_num_dofs);
    Ey = vecxd::Zero(p_num_dofs);
    Ez = vecxd::Zero(p_num_dofs);
    Hx = vecxd::Zero(p_num_dofs);
    Hy = vecxd::Zero(p_num_dofs);
    Hz = vecxd::Zero(p_num_dofs);
    num_dofs = p_num_dofs;
}

#ifdef ENABLE_GPU_SOLVER

pinned_field::pinned_field()
    : Ex(nullptr), Ey(nullptr), Ez(nullptr),
      Hx(nullptr), Hy(nullptr), Hz(nullptr),
      num_dofs(0)
{}

void
pinned_field::zero()
{
    memset(Ex, '\0', num_dofs*sizeof(double));
    memset(Ey, '\0', num_dofs*sizeof(double));
    memset(Ez, '\0', num_dofs*sizeof(double));
    memset(Hx, '\0', num_dofs*sizeof(double));
    memset(Hy, '\0', num_dofs*sizeof(double));
    memset(Hz, '\0', num_dofs*sizeof(double));
}

void
pinned_field::resize(size_t sz)
{
    if (Ex and sz != num_dofs) checkGPU( gpuFreeHost(Ex) );
    if (Ey and sz != num_dofs) checkGPU( gpuFreeHost(Ey) );
    if (Ez and sz != num_dofs) checkGPU( gpuFreeHost(Ez) );
    if (Hx and sz != num_dofs) checkGPU( gpuFreeHost(Hx) );
    if (Hy and sz != num_dofs) checkGPU( gpuFreeHost(Hy) );
    if (Hz and sz != num_dofs) checkGPU( gpuFreeHost(Hz) );
    
    zero();

    checkGPU( gpuMallocHost((void**)&Ex, sz*sizeof(double)) );
    checkGPU( gpuMallocHost((void**)&Ey, sz*sizeof(double)) );
    checkGPU( gpuMallocHost((void**)&Ez, sz*sizeof(double)) );
    checkGPU( gpuMallocHost((void**)&Hx, sz*sizeof(double)) );
    checkGPU( gpuMallocHost((void**)&Hy, sz*sizeof(double)) );
    checkGPU( gpuMallocHost((void**)&Hz, sz*sizeof(double)) );
    num_dofs = sz;
}

pinned_field::~pinned_field()
{
    if (Ex) checkGPU( gpuFreeHost(Ex) );
    if (Ey) checkGPU( gpuFreeHost(Ey) );
    if (Ez) checkGPU( gpuFreeHost(Ez) );
    if (Hx) checkGPU( gpuFreeHost(Hx) );
    if (Hy) checkGPU( gpuFreeHost(Hy) );
    if (Hz) checkGPU( gpuFreeHost(Hz) );
}

void
field_gpu::zero()
{
    Ex.zero();
    Ey.zero();
    Ez.zero();
    Hx.zero();
    Hy.zero();
    Hz.zero();
}
void
field_gpu::resize(size_t p_num_dofs)
{
    Ex.resize(p_num_dofs);
    Ey.resize(p_num_dofs);
    Ez.resize(p_num_dofs);
    Hx.resize(p_num_dofs);
    Hy.resize(p_num_dofs);
    Hz.resize(p_num_dofs);
    zero();
    num_dofs = p_num_dofs;
}

field_gpu::raw_ptrs
field_gpu::data(void)
{
    raw_ptrs ret;

    ret.num_dofs = num_dofs;
    ret.Ex = Ex.data();
    ret.Ey = Ey.data();
    ret.Ez = Ez.data();
    ret.Hx = Hx.data();
    ret.Hy = Hy.data();
    ret.Hz = Hz.data();

    return ret;
}

field_gpu::const_raw_ptrs
field_gpu::data(void) const
{
    const_raw_ptrs ret;

    ret.num_dofs = num_dofs;
    ret.Ex = Ex.data();
    ret.Ey = Ey.data();
    ret.Ez = Ez.data();
    ret.Hx = Hx.data();
    ret.Hy = Hy.data();
    ret.Hz = Hz.data();

    return ret;
}

void
field_gpu::copyin(const field& emf)
{
    Ex.copyin(emf.Ex.data(), emf.Ex.size());
    Ey.copyin(emf.Ey.data(), emf.Ey.size());
    Ez.copyin(emf.Ez.data(), emf.Ez.size());
    Hx.copyin(emf.Hx.data(), emf.Hx.size());
    Hy.copyin(emf.Hy.data(), emf.Hy.size());
    Hz.copyin(emf.Hz.data(), emf.Hz.size());
}

void
field_gpu::copyin(const field& emf, const stream& st)
{
    Ex.copyin(emf.Ex.data(), emf.Ex.size(), st);
    Ey.copyin(emf.Ey.data(), emf.Ey.size(), st);
    Ez.copyin(emf.Ez.data(), emf.Ez.size(), st);
    Hx.copyin(emf.Hx.data(), emf.Hx.size(), st);
    Hy.copyin(emf.Hy.data(), emf.Hy.size(), st);
    Hz.copyin(emf.Hz.data(), emf.Hz.size(), st);
}

void
field_gpu::copyin(const pinned_field& emf, const stream& st)
{
    Ex.copyin(emf.Ex, emf.num_dofs, st);
    Ey.copyin(emf.Ey, emf.num_dofs, st);
    Ez.copyin(emf.Ez, emf.num_dofs, st);
    Hx.copyin(emf.Hx, emf.num_dofs, st);
    Hy.copyin(emf.Hy, emf.num_dofs, st);
    Hz.copyin(emf.Hz, emf.num_dofs, st);
}

void
field_gpu::copyout(field& emf) const
{
    if (num_dofs != emf.num_dofs)
        emf.resize(num_dofs);

    Ex.copyout(emf.Ex.data());
    Ey.copyout(emf.Ey.data());
    Ez.copyout(emf.Ez.data());
    Hx.copyout(emf.Hx.data());
    Hy.copyout(emf.Hy.data());
    Hz.copyout(emf.Hz.data());
}



material_params_gpu::raw_ptrs
material_params_gpu::data(void)
{
    material_params_gpu::raw_ptrs ret;
    ret.num_dofs            = num_dofs;
    ret.num_fluxes          = num_fluxes;
    ret.inv_epsilon         = inv_epsilon.data();
    ret.inv_mu              = inv_mu.data();
    ret.sigma               = sigma.data();
    ret.sigma_over_epsilon  = sigma_over_epsilon.data();
    ret.aE                  = aE.data();
    ret.bE                  = bE.data();
    ret.aH                  = aH.data();
    ret.bH                  = bH.data();
    ret.bc_coeffs           = bc_coeffs.data();
    return ret;
}

material_params_gpu::const_raw_ptrs
material_params_gpu::data(void) const
{
    material_params_gpu::const_raw_ptrs ret;
    ret.num_dofs            = num_dofs;
    ret.num_fluxes          = num_fluxes;
    ret.inv_epsilon         = inv_epsilon.data();
    ret.inv_mu              = inv_mu.data();
    ret.sigma               = sigma.data();
    ret.sigma_over_epsilon  = sigma_over_epsilon.data();
    ret.aE                  = aE.data();
    ret.bE                  = bE.data();
    ret.aH                  = aH.data();
    ret.bH                  = bH.data();
    ret.bc_coeffs           = bc_coeffs.data();
    return ret;
}

void
material_params_gpu::copyin(const material_params& mp)
{
    num_dofs    = mp.num_dofs;
    num_fluxes  = mp.num_fluxes;

    inv_epsilon.copyin(mp.inv_epsilon.data(), mp.inv_epsilon.size());
    inv_mu.copyin(mp.inv_mu.data(), mp.inv_mu.size());
    sigma.copyin(mp.sigma.data(), mp.sigma.size());
    sigma_over_epsilon.copyin(mp.sigma_over_epsilon.data(), mp.sigma_over_epsilon.size());
    aE.copyin(mp.aE.data(), mp.aE.size());
    bE.copyin(mp.bE.data(), mp.bE.size());
    aH.copyin(mp.aH.data(), mp.aH.size());
    bH.copyin(mp.bH.data(), mp.bH.size());
    bc_coeffs.copyin(mp.bc_coeffs.data(), mp.bc_coeffs.size());
}

#endif /* ENABLE_GPU_SOLVER */

} // namespace maxwell