initFunc.h

Go to the documentation of this file.

#ifndef INITFUNC_H
#define INITFUNC_H

#include "simData.h"


class InitialFunc
{
  public:
    Data * data; 


    InitialFunc(Data * data);

    virtual ~InitialFunc() { }     
};

class AdvectionSingleFluid : public InitialFunc
{
  public:
    AdvectionSingleFluid(Data * data);

    virtual ~AdvectionSingleFluid() { }     
};


class CPAlfvenWaveTwoFluid : public InitialFunc
{
  public:

    CPAlfvenWaveTwoFluid(Data * data);

    virtual ~CPAlfvenWaveTwoFluid() { }     
};


class CPAlfvenWaveSingleFluid : public InitialFunc
{
  public:


    CPAlfvenWaveSingleFluid(Data * data);

    virtual ~CPAlfvenWaveSingleFluid() { }     
};


class CurrentSheetTwoFluid : public InitialFunc
{
  public:


    CurrentSheetTwoFluid(Data * data);

    virtual ~CurrentSheetTwoFluid() { }     
};


class CurrentSheetSingleFluid : public InitialFunc
{
  public:


    CurrentSheetSingleFluid(Data * data, int direction=0);

    virtual ~CurrentSheetSingleFluid() { }     
};



class OTVortexSingleFluid : public InitialFunc
{
  public:


    OTVortexSingleFluid(Data * data);

    virtual ~OTVortexSingleFluid() { }     
};




class BrioWuTwoFluid : public InitialFunc
{
  public:

    BrioWuTwoFluid(Data * data, int dir=0, int setUp=1);

    virtual ~BrioWuTwoFluid() { }     
};


class BrioWuSingleFluid : public InitialFunc
{
  public:
    BrioWuSingleFluid(Data * data, int dir=0);

    virtual ~BrioWuSingleFluid() { }     
};


class KHInstabilitySingleFluid : public InitialFunc
{
  public:
    KHInstabilitySingleFluid(Data * data, int mag=0);

    virtual ~KHInstabilitySingleFluid() { }     
};


class KHRandomInstabilitySingleFluid : public InitialFunc
{
  public:
    KHRandomInstabilitySingleFluid(Data * data, int mag=0, int seed=1234);

    virtual ~KHRandomInstabilitySingleFluid() { }     
};


class KHInstabilityTwoFluid : public InitialFunc
{
  public:
    KHInstabilityTwoFluid(Data * data, int mag=0);

    virtual ~KHInstabilityTwoFluid() { }     
};



class FieldLoopAdvectionSingleFluid : public InitialFunc
{
  public:
    FieldLoopAdvectionSingleFluid(Data * data);

    virtual ~FieldLoopAdvectionSingleFluid() { }     
};



class ResistiveReconnectionSingleFluid : public InitialFunc
{
  public:
    ResistiveReconnectionSingleFluid(Data * data);

    virtual ~ResistiveReconnectionSingleFluid() { }     

};


class MagneticRotorSingleFluid : public InitialFunc
{
  public:
    MagneticRotorSingleFluid(Data * data);

    virtual ~MagneticRotorSingleFluid() { }     
};


class SphericalBlastWaveSingleFluid : public InitialFunc
{
  public:
    SphericalBlastWaveSingleFluid(Data * data);

    virtual ~SphericalBlastWaveSingleFluid() { }     
};



class RotatedBrioWu2DSingleFluid : public InitialFunc
{
  public:
    RotatedBrioWu2DSingleFluid(Data * data);

    virtual ~RotatedBrioWu2DSingleFluid() { }     
};



class PerturbedBrioWu2DSingleFluid : public InitialFunc
{
  public:
    PerturbedBrioWu2DSingleFluid(Data * data);

    virtual ~PerturbedBrioWu2DSingleFluid() { }     
};



class FancyMETHODData : public InitialFunc
{
  public:
    FancyMETHODData(Data * data);

    bool inM(double x, double y);
    bool inE(double x, double y);
    bool inT(double x, double y);
    bool inH(double x, double y);
    bool inO(double x, double y);
    bool inD(double x, double y);

    bool inMETHOD(double x, double y);

    virtual ~FancyMETHODData() { }     
};



#endif