/// @file InOutput.h
/// Declarations for I/O implemenatation.
#ifndef __INOUTPUT_H
#define __INOUTPUT_H

class OutputParams;
class OutputIntParams;
#include "DataManager.h"

int64_t ncGetCount(std::string typedir);

/// @brief Base class for output parameters.
///
/// This is an abstract class from which an output parameter class can
/// be derived.  Derived classes need to implement dValue() or
/// vValue() which returns the value to be output for a given particle.
class OutputParams : public PUP::able 
{
 public:
    virtual double dValue(GravityParticle *p) = 0;
    virtual Vector3D<double> vValue(GravityParticle *p) = 0;
    virtual void setDValue(GravityParticle *p, double) = 0;
    int bVector;	// Is a vector, as opposed to a scalar
    int iBinaryOut;     // Type of binary output
    double dTime;
    std::string fileName;	// output file
    std::string sTipsyExt;      // Extension for tipsy output
    std::string sNChilExt;      // file name for NChilada output
    unsigned int iType;         // mask of families containing this attribute
    DataManager *dm;	// For extra state information (e.g. cooling)

    OutputParams() {dm = NULL;}
    PUPable_abstract(OutputParams);
    OutputParams(CkMigrateMessage *m) : PUP::able(m) {dm = NULL;}
    virtual void pup(PUP::er &p) {
        PUP::able::pup(p);//Call base class
        p|fileName;
        p|sTipsyExt;
        p|sNChilExt;
        p|bVector;
        p|iBinaryOut;
        p|dTime;
        p|iType;
	}
    };

/// @brief Output particle masses
class MassOutputParams : public OutputParams
{
 public:
    virtual double dValue(GravityParticle *p) {return p->mass;}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {p->mass = val;}
    MassOutputParams() {}
    MassOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "mass"; sNChilExt = "mass";
        dTime = _dTime;
        iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
    PUPable_decl(MassOutputParams);
    MassOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output particle positions
class PosOutputParams : public OutputParams
{
 public:
    virtual double dValue(GravityParticle *p) {CkAssert(0); return 0.0;}
    virtual Vector3D<double> vValue(GravityParticle *p)
				{return p->position;}
    virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
    PosOutputParams() {}
    PosOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 1; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "pos"; sNChilExt = "pos";
        dTime = _dTime;
        iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
    PUPable_decl(PosOutputParams);
    PosOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output particle velocities
class VelOutputParams : public OutputParams
{
 public:
    double dVFac;
    virtual double dValue(GravityParticle *p) {CkAssert(0); return 0.0;}
    virtual Vector3D<double> vValue(GravityParticle *p)
				{return dVFac*p->velocity;}
    virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
    VelOutputParams() {}
    VelOutputParams(std::string _fileName, int _iBinaryOut, double _dTime,
                    double _dVFac) {
        bVector = 1; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "vel"; sNChilExt = "vel";
        dTime = _dTime; dVFac = _dVFac;
        iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
    PUPable_decl(VelOutputParams);
    VelOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
        p|dVFac;
	}
    };

/// @brief Output particle gravitational potential
class PotOutputParams : public OutputParams
{
 public:
    virtual double dValue(GravityParticle *p) {return p->potential;}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {p->potential = val;}
    PotOutputParams() {}
    PotOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "pot"; sNChilExt = "pot";
        dTime = _dTime;
        iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
    PUPable_decl(PotOutputParams);
    PotOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output particle gas density
class GasDenOutputParams : public OutputParams
{
 public:
    virtual double dValue(GravityParticle *p) {return p->fDensity;}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {p->fDensity = val;}
    GasDenOutputParams() {}
    GasDenOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "gasden"; sNChilExt = "GasDensity";
        dTime = _dTime;
        iType = TYPE_GAS; }
    PUPable_decl(GasDenOutputParams);
    GasDenOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output particle gas temperature
class TempOutputParams : public OutputParams
{
 public:
    double duTFac;
    bool bGasCooling;
    virtual double dValue(GravityParticle *p) {
        if(bGasCooling) {
#ifndef COOLING_NONE
            return CoolCodeEnergyToTemperature(dm->Cool, &p->CoolParticle(),
                                               p->u(), p->fMetals());
#else
            CkAssert(0);
#endif
            }
        return duTFac*p->u();
        }
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
    TempOutputParams() {}
    TempOutputParams(std::string _fileName, int _iBinaryOut, double _dTime,
                     bool _bGasCooling, double _duTFac) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "temp"; sNChilExt = "temperature";
        dTime = _dTime; bGasCooling = _bGasCooling; duTFac = _duTFac;
        iType = TYPE_GAS; }
    PUPable_decl(TempOutputParams);
    TempOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
        p|bGasCooling;
        p|duTFac;
	}
    };


/// @brief Output accelerations.
class AccOutputParams : public OutputParams
{
 public:
    virtual double dValue(GravityParticle *p) {CkAssert(0); return 0.0;}
    virtual Vector3D<double> vValue(GravityParticle *p)
				{return p->treeAcceleration;}
    virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
    AccOutputParams() {}
    AccOutputParams(std::string _fileName) { bVector = 1; fileName = _fileName;}
    AccOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 1; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "acc2"; sNChilExt = "acc";
        dTime = _dTime;
        iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
    PUPable_decl(AccOutputParams);
    AccOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };
    
/// @brief Output densities.
class DenOutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p) {return p->fDensity;}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {p->fDensity = val;}
 public:
    DenOutputParams() {}
    DenOutputParams(std::string _fileName) { bVector = 0; fileName = _fileName;}
    DenOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "den"; sNChilExt = "den";
        dTime = _dTime;
        iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
    PUPable_decl(DenOutputParams);
    DenOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output smoothing lengths.
class HsmOutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p) {return 0.5*p->fBall;}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {p->fBall = 2.0*val;}
 public:
    HsmOutputParams() {}
    HsmOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "smoothlength"; sNChilExt = "smoothlength";
        dTime = _dTime;
        iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
    PUPable_decl(HsmOutputParams);
    HsmOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output particle gravitational softenings
class SoftOutputParams : public OutputParams
{
 public:
    virtual double dValue(GravityParticle *p) {
#ifdef CHANGESOFT
        return p->fSoft0;
#else
        return p->soft;
#endif
    }
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {
#ifdef CHANGESOFT
	p->fSoft0 = val;
#else
	p->soft = val;
#endif
	}
    SoftOutputParams() {}
    SoftOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "soft"; sNChilExt = "soft";
        dTime = _dTime;
        iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
    PUPable_decl(SoftOutputParams);
    SoftOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output pressure.
class PresOutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p)
    {
	if (TYPETest(p, TYPE_GAS))
	    return p->fDensity*p->fDensity*p->PoverRho2();
	else
	    return 0.0;
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
 public:
    PresOutputParams() {}
    PresOutputParams(std::string _fileName) { bVector = 0; fileName = _fileName;}
    PresOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "pres"; sNChilExt = "pres";
        dTime = _dTime;
        iType = TYPE_GAS; }
    PUPable_decl(PresOutputParams);
    PresOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output divergence of velocity.
class DivVOutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p)
    {
	if (TYPETest(p, TYPE_GAS))
	    return p->divv();
	else
	    return 0.0;
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {p->divv() = val;}
 public:
    DivVOutputParams() {}
    DivVOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "divv"; sNChilExt = "divv";
        dTime = _dTime;
        iType = TYPE_GAS; }
    PUPable_decl(DivVOutputParams);
    DivVOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output pressure times change in volume.
class PDVOutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p)
    {
	if (TYPETest(p, TYPE_GAS))
	    return p->PdV();
	else
	    return 0.0;
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {p->PdV() = val;}
 public:
    PDVOutputParams() {}
    PDVOutputParams(std::string _fileName) { bVector = 0; fileName = _fileName;}
    PDVOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "PdV"; sNChilExt = "PdV";
        dTime = _dTime;
        iType = TYPE_GAS; }
    PUPable_decl(PDVOutputParams);
    PDVOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output artificial viscosity mumax.
class MuMaxOutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p)
    {
	if (TYPETest(p, TYPE_GAS))
	    return p->mumax();
	else
	    return 0.0;
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {p->mumax() = val;}
 public:
    MuMaxOutputParams() {}
    MuMaxOutputParams(std::string _fileName) { bVector = 0; fileName = _fileName;}
    MuMaxOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "mumax"; sNChilExt = "mumax";
        dTime = _dTime;
        iType = TYPE_GAS; }
    PUPable_decl(MuMaxOutputParams);
    MuMaxOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output value of Balsara switch.
class BSwOutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p)
    {
	if (TYPETest(p, TYPE_GAS))
	    return p->BalsaraSwitch();
	else
	    return 0.0;
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {p->BalsaraSwitch() = val;}
 public:
    BSwOutputParams() {}
    BSwOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "BSw"; sNChilExt = "BSw";
        dTime = _dTime;
        iType = TYPE_GAS; }
    PUPable_decl(BSwOutputParams);
    BSwOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output sound speed.
class CsOutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p)
    {
	if (TYPETest(p, TYPE_GAS))
	    return p->c();
	else
	    return 0.0;
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {p->c() = val;}
 public:
    CsOutputParams() {}
    CsOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "c"; sNChilExt = "c";
        dTime = _dTime;
        iType = TYPE_GAS; }
    PUPable_decl(CsOutputParams);
    CsOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output the cooling rate.
class EDotOutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p)
    {
#ifndef COOLING_NONE
	CkAssert(dm != NULL);
	if (TYPETest(p, TYPE_GAS)) {
	    double r[3];  // For conversion to C
	    p->position.array_form(r);
	    return (COOL_EDOT(dm->Cool, &p->CoolParticle(), p->u(), p->fDensity, p->fMetals(), r));
	    }
	else
#endif
	    return 0.0;
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
 public:
    EDotOutputParams() {}
    EDotOutputParams(std::string _fileName) { bVector = 0; fileName = _fileName;}
    EDotOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "eDot"; sNChilExt = "eDot";
        dTime = _dTime;
        iType = TYPE_GAS; }
    PUPable_decl(EDotOutputParams);
    EDotOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output the value in cool_array0.
class Cool0OutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p)
    {
#ifndef COOLING_NONE
	if (TYPETest(p, TYPE_GAS))
	    return COOL_ARRAY0(unused1, &p->CoolParticle(), unused2);
	else
#endif
	    return 0.0;
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {
#ifndef COOLING_NONE
	if (TYPETest(p, TYPE_GAS))
	    COOL_ARRAY0(unused1, &p->CoolParticle(), unused2) = val;
#endif
	}
 public:
    Cool0OutputParams() {}
    Cool0OutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
#ifndef COOLING_NONE
        sTipsyExt = COOL_ARRAY0_EXT; sNChilExt = COOL_ARRAY0_EXT;
#endif
        dTime = _dTime;
        iType = TYPE_GAS; }
    PUPable_decl(Cool0OutputParams);
    Cool0OutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output the value in cool_array1.
class Cool1OutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p)
    {
#ifndef COOLING_NONE
	if (TYPETest(p, TYPE_GAS))
	    return COOL_ARRAY1(unused1, &p->CoolParticle(), unused2);
	else
#endif
	    return 0.0;
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {
#ifndef COOLING_NONE
	if (TYPETest(p, TYPE_GAS))
	    COOL_ARRAY1(unused1, &p->CoolParticle(), unused2) = val;
#endif
	}
 public:
    Cool1OutputParams() {}
    Cool1OutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
#ifndef COOLING_NONE
        sTipsyExt = COOL_ARRAY1_EXT; sNChilExt = COOL_ARRAY1_EXT;
#endif
        dTime = _dTime;
        iType = TYPE_GAS; }
    PUPable_decl(Cool1OutputParams);
    Cool1OutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output the value in cool_array2.
class Cool2OutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p)
    {
#ifndef COOLING_NONE
	if (TYPETest(p, TYPE_GAS))
	    return COOL_ARRAY2(unused1, &p->CoolParticle(), unused2);
	else
#endif
	    return 0.0;
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {
#ifndef COOLING_NONE
	if (TYPETest(p, TYPE_GAS))
	    COOL_ARRAY2(unused1, &p->CoolParticle(), unused2) = val;
#endif
	}
 public:
    Cool2OutputParams() {}
    Cool2OutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
#ifndef COOLING_NONE
        sTipsyExt = COOL_ARRAY2_EXT; sNChilExt = COOL_ARRAY2_EXT;
#endif
        dTime = _dTime;
        iType = TYPE_GAS; }
    PUPable_decl(Cool2OutputParams);
    Cool2OutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output the value in cool_array3.
class Cool3OutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p)
    {
#ifndef COOLING_NONE
	if (TYPETest(p, TYPE_GAS))
	    return COOL_ARRAY3(unused1, &p->CoolParticle(), unused2);
	else
#endif
	    return 0.0;
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {
#ifndef COOLING_NONE
	if (TYPETest(p, TYPE_GAS))
	    CkAssert(0);
#endif
	}
 public:
    Cool3OutputParams() {}
    Cool3OutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
#ifndef COOLING_NONE
        sTipsyExt = COOL_ARRAY3_EXT; sNChilExt = COOL_ARRAY3_EXT;
#endif
        dTime = _dTime;
        iType = TYPE_GAS; }
    PUPable_decl(Cool3OutputParams);
    Cool3OutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output Oxygen mass fraction.
class OxOutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p) {
	if (TYPETest(p, TYPE_STAR)) return p->fStarMFracOxygen();
	if (TYPETest(p, TYPE_GAS)) return p->fMFracOxygen();
	else return 0.0;
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {
	if (TYPETest(p, TYPE_STAR)) p->fStarMFracOxygen() = val;
	if (TYPETest(p, TYPE_GAS)) p->fMFracOxygen() = val;
	}
 public:
    OxOutputParams() {}
    OxOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "OxMassFrac"; sNChilExt = "OxMassFrac";
        dTime = _dTime;
        iType = TYPE_GAS | TYPE_STAR; }
    PUPable_decl(OxOutputParams);
    OxOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output Iron mass fraction.
class FeOutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p) {
	if (TYPETest(p, TYPE_STAR)) return p->fStarMFracIron();
	if (TYPETest(p, TYPE_GAS)) return p->fMFracIron();
	else return 0.0;
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {
	if (TYPETest(p, TYPE_STAR)) p->fStarMFracIron() = val;
	if (TYPETest(p, TYPE_GAS)) p->fMFracIron() = val;
	}
 public:
    FeOutputParams() {}
    FeOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "FeMassFrac"; sNChilExt = "FeMassFrac";
        dTime = _dTime;
        iType = TYPE_GAS | TYPE_STAR; }
    PUPable_decl(FeOutputParams);
    FeOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output metal mass fraction.
class MetalsOutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p) {
	if (TYPETest(p, TYPE_STAR)) return p->fStarMetals();
	if (TYPETest(p, TYPE_GAS)) return p->fMetals();
	else return 0.0;
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {
	if (TYPETest(p, TYPE_STAR)) p->fStarMetals() = val;
	if (TYPETest(p, TYPE_GAS)) p->fMetals() = val;
        }
 public:
    MetalsOutputParams() {}
    MetalsOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "metals"; sNChilExt = "metals";
        dTime = _dTime;
        iType = TYPE_GAS | TYPE_STAR; }
    PUPable_decl(MetalsOutputParams);
    MetalsOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

class MFormOutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p) {
	if (TYPETest(p, TYPE_STAR)) return p->fMassForm();
	else return 0.0;
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {
	if (TYPETest(p, TYPE_STAR)) p->fMassForm() = val;
	}
 public:
    MFormOutputParams() {}
    MFormOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "massform"; sNChilExt = "massform";
        dTime = _dTime;
        iType = TYPE_STAR; }
    PUPable_decl(MFormOutputParams);
    MFormOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

class TimeFormOutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p) {
	if (TYPETest(p, TYPE_STAR)) return p->fTimeForm();
	else return 0.0;
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {
	if (TYPETest(p, TYPE_STAR)) p->fTimeForm() = val;
        }
 public:
    TimeFormOutputParams() {}
    TimeFormOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "timeform"; sNChilExt = "timeform";
        dTime = _dTime;
        iType = TYPE_STAR; }
    PUPable_decl(TimeFormOutputParams);
    TimeFormOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };


/// @brief Output "cool on time" (time cooling is off until)
class coolontimeOutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p) {
	if (TYPETest(p, TYPE_GAS)) return p->fTimeCoolIsOffUntil();
	else return 0.0;
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {
	if (TYPETest(p, TYPE_GAS)) p->fTimeCoolIsOffUntil() = val;
	}
 public:
    coolontimeOutputParams() {}
    coolontimeOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "coolontime"; sNChilExt = "coolontime";
        dTime = _dTime;
        iType = TYPE_GAS; }
    PUPable_decl(coolontimeOutputParams);
    coolontimeOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output Supernova heating rate
class ESNRateOutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p) {
	if (p->isGas()) return p->fESNrate();
	else if(p->isStar()) return p->fStarESNrate();
	else return 0.0;
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {
	if (p->isGas()) p->fESNrate() = val;
	else if(p->isStar()) p->fStarESNrate() = val;
	}
 public:
    ESNRateOutputParams() {}
    ESNRateOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "ESNRate"; sNChilExt = "ESNRate";
        dTime = _dTime;
        iType = TYPE_GAS | TYPE_STAR; }
    PUPable_decl(ESNRateOutputParams);
    ESNRateOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output timesteps.
class DtOutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p)
    {
#ifdef NEED_DT
	return p->dt;
#else
	return 0.0;
#endif
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {
#ifdef NEED_DT
	p->dt = val;
#endif
	}
 public:
    DtOutputParams() {}
    DtOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "dt"; sNChilExt = "dt";
        dTime = _dTime;
        iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
    PUPable_decl(DtOutputParams);
    DtOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output Keys.
class KeyOutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p)
    {
	return p->key;
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
 public:
    KeyOutputParams() {}
    KeyOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "key"; sNChilExt = "key";
        dTime = _dTime;
        iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
    PUPable_decl(KeyOutputParams);
    KeyOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Output Domains.
class DomainOutputParams : public OutputParams
{
    virtual double dValue(GravityParticle *p)
    {
	return p->interMass; // Hack: this gets assigned in assignDomain()
			     // just for this diagnostic.
	}
    virtual Vector3D<double> vValue(GravityParticle *p)
			    {CkAssert(0); return 0.0;}
    virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
 public:
    DomainOutputParams() {}
    DomainOutputParams(std::string _fileName) { bVector = 0; fileName = _fileName;}
    DomainOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "dom"; sNChilExt = "dom";
        dTime = _dTime;
        iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
    PUPable_decl(DomainOutputParams);
    DomainOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputParams::pup(p);//Call base class
	}
    };

/// @brief Base class for Integer output parameters.
///
/// This is an abstract class from which an output parameter class can
/// be derived.  Derived classes need to implement iValue()
/// which returns the value to be output for a given particle.
class OutputIntParams : public PUP::able 
{
 public:
    virtual int64_t iValue(GravityParticle *p) = 0;
    virtual void setIValue(GravityParticle *p, int64_t iValue) = 0;
    int iBinaryOut;     // Type of binary output
    double dTime;
    std::string fileName;	// output file
    std::string sTipsyExt;      // Extension for tipsy output
    std::string sNChilExt;      // file name for NChilada output
    unsigned int iType;         // mask of families containing this attribute

    OutputIntParams() {}
    PUPable_abstract(OutputIntParams);
    OutputIntParams(CkMigrateMessage *m) : PUP::able(m) {}
    virtual void pup(PUP::er &p) {
        PUP::able::pup(p);//Call base class
        p|fileName;
        p|sTipsyExt;
        p|sNChilExt;
        p|iBinaryOut;
        p|dTime;
        p|iType;
	}
    };

/// @brief Output iOrder.
class IOrderOutputParams : public OutputIntParams
{
    virtual int64_t iValue(GravityParticle *p)
    {
	return p->iOrder;
	}
    virtual void setIValue(GravityParticle *p, int64_t iValue)
    {
	p->iOrder = iValue;
	}
 public:
    IOrderOutputParams() {}
    IOrderOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "iord"; sNChilExt = "iord";
        dTime = _dTime;
        iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
    PUPable_decl(IOrderOutputParams);
    IOrderOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputIntParams::pup(p);//Call base class
	}
    };

/// @brief Output iGasOrder.
class IGasOrderOutputParams : public OutputIntParams
{
    virtual int64_t iValue(GravityParticle *p)
    {
	if(p->isStar())
	    return p->iGasOrder();
	else
	    return 0;
	}
    virtual void setIValue(GravityParticle *p, int64_t iValue)
    {
        p->iGasOrder() = iValue;
	}
 public:
    IGasOrderOutputParams() {}
    IGasOrderOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "igasorder"; sNChilExt = "igasorder";
        dTime = _dTime;
        iType = TYPE_STAR; }
    PUPable_decl(IGasOrderOutputParams);
    IGasOrderOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputIntParams::pup(p);//Call base class
	}
    };

/// @brief Output rungs.
class RungOutputParams : public OutputIntParams
{
    virtual int64_t iValue(GravityParticle *p)
    {
	return p->rung;
	}
    virtual void setIValue(GravityParticle *p, int64_t iValue)
    {
        p->rung = iValue;
	}
 public:
    RungOutputParams() {}
    RungOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
        fileName = _fileName; iBinaryOut = _iBinaryOut;
        sTipsyExt = "rung"; sNChilExt = "rung";
        dTime = _dTime;
        iType = TYPE_GAS| TYPE_DARK | TYPE_STAR; }
    PUPable_decl(RungOutputParams);
    RungOutputParams(CkMigrateMessage *m) {}
    virtual void pup(PUP::er &p) {
        OutputIntParams::pup(p);//Call base class
	}
    };
#endif