Grad.h

#ifndef gridripper_amr1d_Grad_h
#define gridripper_amr1d_Grad_h

#include <gridripper/tvalarray.h>
#include <gridripper/lang/IllegalArgumentException.h>
#include "FieldWrapper.h"
#include <string>

namespace gridripper { namespace amr1d {

using namespace std;
class Grid;
class PDE;
class FieldWrapper;

class Grad
{
public:
    virtual ~Grad() { }

    void d(const Grid& g, PDE* pde, int i, FieldWrapper& result) {
        d(g, pde, i, result.data(), result.size());
    }

    void d(const Grid& g, PDE* pde, int i, tvalarray<GReal_t>& result) {
        d(g, pde, i, (GReal_t*)result, result.size());
    }

    void d2(Grid& g, PDE* pde, int i, FieldWrapper& result) {
        d2(g, pde, i, result.data(), result.size());
    }

    void d2(Grid& g, PDE* pde, int i, tvalarray<GReal_t>& result) {
        d2(g, pde, i, (GReal_t*)result, result.size());
    }

    virtual void d(const Grid& g, PDE* pde, int i, GReal_t* result, int size)
                =0;

    virtual void d2(const Grid& g, PDE* pde, int i, GReal_t* result, int size)
                =0;

    virtual int getNumVelocity() =0;

    virtual Grad* create(const PDE& pde, int level) const =0;

    virtual string toString() const =0;

    static Grad* clone(const Grad* d);

    static void createPair(const string& name,
                           const PDE& pde, int level, Grad** d)
        throw(IllegalArgumentException&);

protected:
    virtual Grad* clone() const =0;
};

// First order finite difference schemes

class Grad_O1_shifted: public Grad
{
private:
    const PDE& thePDE;
    int theLevel;
    FieldWrapper& fw0;
    FieldWrapper& fw1;

public:
    Grad_O1_shifted(const PDE& pde, int level);
    ~Grad_O1_shifted();

    int getNumVelocity() {
        return 1;
    }

    void d(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    void d2(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    Grad* create(const PDE& pde, int level) const {
        return new Grad_O1_shifted(pde, level);
    }

    string toString() const {
        return "Grad_O1_shifted";
    }

protected:
    Grad* clone() const {
        return new Grad_O1_shifted(thePDE, theLevel);
    }
};

class Grad_O1_shifted_2: public Grad
{
private:
    const PDE& thePDE;
    int theLevel;
    FieldWrapper& fw0;
    FieldWrapper& fw1;

public:
    Grad_O1_shifted_2(const PDE& pde, int level);
    ~Grad_O1_shifted_2();

    int getNumVelocity() {
        return 2;
    }

    void d(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    void d2(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    Grad* create(const PDE& pde, int level) const {
        return new Grad_O1_shifted_2(pde, level);
    }

    string toString() const {
        return "Grad_O1_shifted_2";
    }

protected:
    Grad* clone() const {
        return new Grad_O1_shifted_2(thePDE, theLevel);
    }
};

// Second order finite difference schemes

class Grad_O2: public Grad
{
private:
    const PDE& thePDE;
    int theLevel;
    FieldWrapper& fw0;
    FieldWrapper& fw1;
    FieldWrapper& fw2;

public:
    Grad_O2(const PDE& pde, int level);
    ~Grad_O2();

    int getNumVelocity() {
        return 1;
    }

    void d(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    void d2(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    Grad* create(const PDE& pde, int level) const {
        return new Grad_O2(pde, level);
    }

    string toString() const {
        return "Grad_O2";
    }

protected:
    Grad* clone() const {
        return new Grad_O2(thePDE, theLevel);
    }
};

class Grad_O2_2: public Grad
{
private:
    const PDE& thePDE;
    int theLevel;
    FieldWrapper& fw0;
    FieldWrapper& fw1;
    FieldWrapper& fw2;

public:
    Grad_O2_2(const PDE& pde, int level);
    ~Grad_O2_2();

    int getNumVelocity() {
        return 2;
    }

    void d(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    void d2(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    Grad* create(const PDE& pde, int level) const {
        return new Grad_O2_2(pde, level);
    }

    string toString() const {
        return "Grad_O2_2";
    }

protected:
    Grad* clone() const {
        return new Grad_O2_2(thePDE, theLevel);
    }
};

class Grad_O21: public Grad
{
private:
    const PDE& thePDE;
    int theLevel;
    FieldWrapper& fw0;
    FieldWrapper& fw1;
    FieldWrapper& fw2;

public:
    Grad_O21(const PDE& pde, int level);
    ~Grad_O21();

    int getNumVelocity() {
        return 1;
    }

    void d(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    void d2(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    Grad* create(const PDE& pde, int level) const {
        return new Grad_O21(pde, level);
    }

    string toString() const {
        return "Grad_O21";
    }

protected:
    Grad* clone() const {
        return new Grad_O21(thePDE, theLevel);
    }
};

class Grad_O21_2: public Grad
{
private:
    const PDE& thePDE;
    int theLevel;
    FieldWrapper& fw0;
    FieldWrapper& fw1;
    FieldWrapper& fw2;

public:
    Grad_O21_2(const PDE& pde, int level);
    ~Grad_O21_2();

    int getNumVelocity() {
        return 2;
    }

    void d(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    void d2(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    Grad* create(const PDE& pde, int level) const {
        return new Grad_O21_2(pde, level);
    }

    string toString() const {
        return "Grad_O21_2";
    }

protected:
    Grad* clone() const {
        return new Grad_O21_2(thePDE, theLevel);
    }
};

// Fourth order finite difference schemes

class Grad_O4: public Grad
{
private:
    const PDE& thePDE;
    int theLevel;
    FieldWrapper& fw0;
    FieldWrapper& fw1;
    FieldWrapper& fw2;
    FieldWrapper& fw3;
    FieldWrapper& fw4;

public:
    Grad_O4(const PDE& pde, int level);
    ~Grad_O4();

    int getNumVelocity() {
        return 2;
    }

    void d(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    void d2(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    Grad* create(const PDE& pde, int level) const {
        return new Grad_O4(pde, level);
    }

    string toString() const {
        return "Grad_O4";
    }

protected:
    Grad* clone() const {
        return new Grad_O4(thePDE, theLevel);
    }
};

class Grad_O4_2: public Grad
{
private:
    const PDE& thePDE;
    int theLevel;
    FieldWrapper& fw0;
    FieldWrapper& fw1;
    FieldWrapper& fw2;
    FieldWrapper& fw3;
    FieldWrapper& fw4;

public:
    Grad_O4_2(const PDE& pde, int level);
    ~Grad_O4_2();

    int getNumVelocity() {
        return 4;
    }

    void d(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    void d2(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    Grad* create(const PDE& pde, int level) const {
        return new Grad_O4_2(pde, level);
    }

    string toString() const {
        return "Grad_O4_2";
    }

protected:
    Grad* clone() const {
        return new Grad_O4_2(thePDE, theLevel);
    }
};

class Grad_O421: public Grad
{
private:
    const PDE& thePDE;
    int theLevel;
    FieldWrapper& fw0;
    FieldWrapper& fw1;
    FieldWrapper& fw2;
    FieldWrapper& fw3;
    FieldWrapper& fw4;

public:
    Grad_O421(const PDE& pde, int level);
    ~Grad_O421();

    int getNumVelocity() {
        return 2;
    }

    void d(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    void d2(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    Grad* create(const PDE& pde, int level) const {
        return new Grad_O421(pde, level);
    }

    string toString() const {
        return "Grad_O421";
    }

protected:
    Grad* clone() const {
        return new Grad_O421(thePDE, theLevel);
    }
};

class Grad_O421_2: public Grad
{
private:
    const PDE& thePDE;
    int theLevel;
    FieldWrapper& fw0;
    FieldWrapper& fw1;
    FieldWrapper& fw2;
    FieldWrapper& fw3;
    FieldWrapper& fw4;

public:
    Grad_O421_2(const PDE& pde, int level);
    ~Grad_O421_2();

    int getNumVelocity() {
        return 4;
    }

    void d(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    void d2(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    Grad* create(const PDE& pde, int level) const {
        return new Grad_O421_2(pde, level);
    }

    string toString() const {
        return "Grad_O421_2";
    }

protected:
    Grad* clone() const {
        return new Grad_O421_2(thePDE, theLevel);
    }
};

// Sixth order finite difference schemes

class Grad_O6: public Grad
{
private:
    const PDE& thePDE;
    int theLevel;
    FieldWrapper& fw0;
    FieldWrapper& fw1;
    FieldWrapper& fw2;
    FieldWrapper& fw3;
    FieldWrapper& fw4;
    FieldWrapper& fw5;
    FieldWrapper& fw6;

public:
    Grad_O6(const PDE& pde, int level);
    ~Grad_O6();

    int getNumVelocity() {
        return 3;
    }

    void d(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    void d2(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    Grad* create(const PDE& pde, int level) const {
        return new Grad_O6(pde, level);
    }

    string toString() const {
        return "Grad_O6";
    }

protected:
    Grad* clone() const {
        return new Grad_O6(thePDE, theLevel);
    }
};

class Grad_O6_2: public Grad
{
private:
    const PDE& thePDE;
    int theLevel;
    FieldWrapper& fw0;
    FieldWrapper& fw1;
    FieldWrapper& fw2;
    FieldWrapper& fw3;
    FieldWrapper& fw4;
    FieldWrapper& fw5;
    FieldWrapper& fw6;

public:
    Grad_O6_2(const PDE& pde, int level);
    ~Grad_O6_2();

    int getNumVelocity() {
        return 6;
    }

    void d(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    void d2(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    Grad* create(const PDE& pde, int level) const {
        return new Grad_O6_2(pde, level);
    }

    string toString() const {
        return "Grad_O6_2";
    }

protected:
    Grad* clone() const {
        return new Grad_O6_2(thePDE, theLevel);
    }
};

class Grad_O6421: public Grad
{
private:
    const PDE& thePDE;
    int theLevel;
    FieldWrapper& fw0;
    FieldWrapper& fw1;
    FieldWrapper& fw2;
    FieldWrapper& fw3;
    FieldWrapper& fw4;
    FieldWrapper& fw5;
    FieldWrapper& fw6;

public:
    Grad_O6421(const PDE& pde, int level);
    ~Grad_O6421();

    int getNumVelocity() {
        return 3;
    }

    void d(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    void d2(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    Grad* create(const PDE& pde, int level) const {
        return new Grad_O6(pde, level);
    }

    string toString() const {
        return "Grad_O6421";
    }

protected:
    Grad* clone() const {
        return new Grad_O6421(thePDE, theLevel);
    }
};

class Grad_O6421_2: public Grad
{
private:
    const PDE& thePDE;
    int theLevel;
    FieldWrapper& fw0;
    FieldWrapper& fw1;
    FieldWrapper& fw2;
    FieldWrapper& fw3;
    FieldWrapper& fw4;
    FieldWrapper& fw5;
    FieldWrapper& fw6;

public:
    Grad_O6421_2(const PDE& pde, int level);
    ~Grad_O6421_2();

    int getNumVelocity() {
        return 6;
    }

    void d(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    void d2(const Grid& g, PDE* pde, int i, GReal_t* result, int size);

    Grad* create(const PDE& pde, int level) const {
        return new Grad_O6_2(pde, level);
    }

    string toString() const {
        return "Grad_O6421_2";
    }

protected:
    Grad* clone() const {
        return new Grad_O6421_2(thePDE, theLevel);
    }
};

} } // namespace gridripper::amr1d

#endif /* gridripper_amr1d_Grad_h */