Metric.h

#ifndef gridripper_metric_Metric_h
#define gridripper_metric_Metric_h


#include <gridripper/math.h>
#include <gridripper/tvector.h>
#include <string>


namespace gridripper { namespace metric {


struct MetricValues
{
    GReal_t r, G00, G01, G10, G11;
    GReal_t invr, invG00, invG01, invG10, invG11;
    GReal_t Volume;
    GReal_t divgtau, divgrho;
    GReal_t rtau, rrho;
    GReal_t rtautau, rtaurho, rrhotau, rrhorho;
    GReal_t Normal0, Normal1, Lapse, Shift0, Shift1, Volume3;
    GReal_t SpatialNormal0, SpatialNormal1, SpatialVolume3;
    GReal_t Killing0, Killing1;
};


class MetricParam : public tvector<GReal_t>
{
    public:
        MetricParam() : tvector<GReal_t>() {  }
        MetricParam(const MetricParam &other) : tvector<GReal_t>(other) {  }
        MetricParam(const GReal_t param1) : tvector<GReal_t>()
        {
            push_back(param1);
        }
        MetricParam(const GReal_t param1, const GReal_t param2) : tvector<GReal_t>()
        {
            push_back(param1);
            push_back(param2);
        }
        MetricParam(const GReal_t param1, const GReal_t param2, const GReal_t param3) : tvector<GReal_t>()
        {
            push_back(param1);
            push_back(param2);
            push_back(param3);
        }
        MetricParam(const GReal_t param1, const GReal_t param2, const GReal_t param3, 
                    const GReal_t param4) : tvector<GReal_t>()
        {
            push_back(param1);
            push_back(param2);
            push_back(param3);
            push_back(param4);
        }
        MetricParam(const GReal_t param1, const GReal_t param2, const GReal_t param3, 
                    const GReal_t param4, const GReal_t param5) : tvector<GReal_t>()
        {
            push_back(param1);
            push_back(param2);
            push_back(param3);
            push_back(param4);
            push_back(param5);
        }
};


class Metric
{
    public:
        enum eval_t { rderiv, metric, metricderiv, all };
    protected:
        const GReal_t rhomin, rhomax;
        const bool isleftinfty, isrightinfty;
        const std::string name;
    private:
        Metric()
         : rhomin(0.0), rhomax(0.0), isleftinfty(false), isrightinfty(false)
        {  }
    public:
        Metric(const Metric &other)
         : rhomin(other.rhomin), rhomax(other.rhomax), 
           isleftinfty(other.isleftinfty), isrightinfty(other.isrightinfty), name(other.name)
        {  }
        Metric(const GReal_t RhoMin, const GReal_t RhoMax, 
               const bool IsLeftInfty, const bool IsRightInfty, const std::string& Name)
         : rhomin(RhoMin), rhomax(RhoMax), 
           isleftinfty(IsLeftInfty),isrightinfty(IsRightInfty), name(Name)
        {  }
        virtual ~Metric() {  }
        virtual void eval(MetricValues &metricvalues, 
                          const GReal_t tau, const GReal_t rho, 
                          const eval_t ev=all) const = 0;
        GReal_t getRhoMin() const { return rhomin; }
        GReal_t getRhoMax() const { return rhomax; }
        bool isLeftInfty() const { return isleftinfty; }
        bool isRightInfty() const { return isrightinfty; }
        std::string getName() const { return name; }
};


class MInert : public Metric
{
    protected:
        GReal_t kappa;
    public:
        MInert(const MInert &other) : Metric(other), kappa(other.kappa) {  }
        MInert(const GReal_t kappaarg) 
         : Metric(0.0, 1.0, false, true, "MInert"), kappa(kappaarg)
        {  }
        void eval(MetricValues &metricvalues, 
                  const GReal_t tau, const GReal_t rho, 
                  const eval_t ev) const;
};


class MHyper : public Metric
{
    protected:
        GReal_t kappa;
    public:
        MHyper(const MHyper &other) : Metric(other), kappa(other.kappa) {  }
        MHyper(const GReal_t kappaarg) 
         : Metric(0.0, 1.0, false, true, "MHyper"), kappa(kappaarg)
        {  }
        void eval(MetricValues &metricvalues, 
                  const GReal_t tau, const GReal_t rho, 
                  const eval_t ev) const;
};


class Sch : public Metric
{
    protected:
        GReal_t kappa, Mass;
    public:
        Sch(const Sch &other) : Metric(other), kappa(other.kappa), Mass(other.Mass) {  }
        Sch(const GReal_t kappaarg, const GReal_t Massarg) 
         : Metric(-1.0, 1.0, true, true, "Sch"), kappa(kappaarg), Mass(Massarg)
        {  }
        void eval(MetricValues &metricvalues, 
                  const GReal_t tau, const GReal_t rho, 
                  const eval_t ev) const;
};


} } // namespace gridripper::metric


#endif /* gridripper_metric_Metric_h */