FieldComponents.h

#ifndef gridripper_amr1d_FieldComponents_h
#define gridripper_amr1d_FieldComponents_h

#include <gridripper/math.h>
#include <gridripper/amr1d/FieldWrapper.h>

namespace gridripper { namespace amr1d {

using namespace std;

template<class K>
class FieldComponents;


template <>
class FieldComponents<GReal_t>;


template <>
class FieldComponents<GComplex_t>;


template <>
class FieldComponents<GReal_t>: public FieldWrapper
{
private:
    int numComponents;

public:
    FieldComponents<GReal_t>(GReal_t* d, int n):
        FieldWrapper(d, n), numComponents(n) {
    }

    FieldComponents<GReal_t>(int n):
        FieldWrapper(n), numComponents(n) {
    }

    FieldComponents<GReal_t>(const FieldComponents<GReal_t>& other):
        FieldWrapper(other), numComponents(other.getNumComponents()) {
    }

    FieldComponents<GReal_t>():
        FieldWrapper(0), numComponents(0) {
    }

    int getNumComponents() const {
        return numComponents;
    }

    GReal_t operator [](int i) const {
        return data()[i];
    }

    GReal_t& operator [](int i) {
        return data()[i];
    }

    bool resize(int n)
    {
        if (ownsData) numComponents=n;
        return FieldWrapper::resize(n);
    }

    virtual FieldWrapper* cloneFieldWrapper() const {
        return new FieldComponents<GReal_t>(*this);
    }

    FieldComponents<GReal_t>& operator=(const FieldComponents<GReal_t>& other)
    {
        FieldWrapper::operator=(other);
        if (ownsData) numComponents=other.numComponents;
        return *this;
    }

};


template <>
class FieldComponents<GComplex_t>: public FieldWrapper
{
private:
    int numComponents;

public:
    FieldComponents<GComplex_t>(GReal_t* d, int n):
        FieldWrapper(d, n*2), numComponents(n) {
    }

    FieldComponents<GComplex_t>(int n):
        FieldWrapper(n*2), numComponents(n) {
    }

    FieldComponents<GComplex_t>(const FieldComponents<GComplex_t>& other):
        FieldWrapper(other), numComponents(other.getNumComponents()) {
    }

    FieldComponents<GComplex_t>():
        FieldWrapper(0*2), numComponents(0) {
    }

    int getNumComponents() const {
        return numComponents;
    }

    const GComplex_t& operator [](int i) const {
        return *(GComplex_t*)(&(data()[i*2]));
    }

    GComplex_t& operator [](int i) {
        return *(GComplex_t*)(&(data()[i*2]));
    }

    bool resize(int n)
    {
        if (ownsData) numComponents=n;
        return FieldWrapper::resize(2*n);
    }

    virtual FieldWrapper* cloneFieldWrapper() const {
        return new FieldComponents<GComplex_t>(*this);
    }

    FieldComponents<GComplex_t>& operator=(const FieldComponents<GComplex_t>& other)
    {
        FieldWrapper::operator=(other);
        if (ownsData) numComponents=other.numComponents;
        return *this;
    }

};


/*
// Modified by Andras Laszlo: I commented out linear operations, 
// as they were not in use. Ask me if you need them.
    FieldComponents& operator +=(const FieldComponents& a) {
        int n1 = getNumComponents();
        int n2 = a.getNumComponents();
        int n = n1 < n2? n1 : n2;
        for(unsigned i = 0; i < n; ++i) {
            (*this)[i] += a[i];
        }
        return *this;
    }

    FieldComponents& operator -=(const FieldComponents& a) {
        int n1 = getNumComponents();
        int n2 = a.getNumComponents();
        int n = n1 < n2? n1 : n2;
        for(unsigned i = 0; i < n; ++i) {
            (*this)[i] -= a[i];
        }
        return *this;
    }

    FieldComponents& operator *=(const T& a) {
        int n = getNumComponents();
        for(unsigned i = 0; i < n; ++i) {
            (*this)[i] *= a;
        }
        return *this;
    }

    FieldComponents& operator /=(const T& a) {
        int n = getNumComponents();
        for(unsigned i = 0; i < n; ++i) {
            (*this)[i] /= a;
        }
        return *this;
    }





template<class T>
FieldComponents<T> operator +(const FieldComponents<T>& a,
                              const FieldComponents<T>& b)
{
    int n1 = a.getNumComponents();
    int n2 = b.getNumComponents();
    int n = n1 > n2? n1 : n2;
    FieldComponents<T> c(n);
    c = a;
    c += b;
    return c;
}

template<class T>
FieldComponents<T> operator -(const FieldComponents<T>& a,
                              const FieldComponents<T>& b)
{
    int n1 = a.getNumComponents();
    int n2 = b.getNumComponents();
    int n = n1 > n2? n1 : n2;
    FieldComponents<T> c(n);
    c = a;
    c -= b;
    return c;
}

template<class T>
FieldComponents<T> operator *(const FieldComponents<T>& a, const T& b)
{
    unsigned n = a.getNumComponents();
    FieldComponents<T> c(n);
    for(unsigned i = 0; i < n; ++i) {
        c[i] = a[i]*b;
    }
    return c;
}

template<class T>
FieldComponents<T> operator *(const T& a, const FieldComponents<T>& b)
{
    unsigned n = b.getNumComponents();
    FieldComponents<T> c(n);
    for(unsigned i = 0; i < n; ++i) {
        c[i] = a*b[i];
    }
    return c;
}

template<class T>
FieldComponents<T> operator /(const FieldComponents<T>& a, const T& b)
{
    unsigned n = a.getNumComponents();
    FieldComponents<T> c(n);
    for(unsigned i = 0; i < n; ++i) {
        c[i] = a[i]/b;
    }
    return c;
}
*/


} } // namespace gridripper::amr1d

#endif /* gridripper_amr1d_FieldComponents_h */