[yt-svn] commit/yt: 2 new changesets
Bitbucket
commits-noreply at bitbucket.org
Mon Apr 30 12:53:26 PDT 2012
2 new commits in yt:
https://bitbucket.org/yt_analysis/yt/changeset/fbd617f638f0/
changeset: fbd617f638f0
branch: yt
user: jwise77
date: 2012-04-30 20:13:10
summary: Adding universal fields for vorticity and its generation from the
barotropic and stretching terms. There are also analogous fields for
simulations with radiation pressure.
affected #: 1 file
diff -r 568d09a73ba25f2da99f410618f74a868d84a55e -r fbd617f638f03d213dadbb58d706642136f3c285 yt/data_objects/universal_fields.py
--- a/yt/data_objects/universal_fields.py
+++ b/yt/data_objects/universal_fields.py
@@ -890,3 +890,376 @@
units=r"\rm{s}^{-2}",
convert_function=_convertVorticitySquared)
+def _gradPressureX(field, data):
+ # We need to set up stencils
+ if data.pf["HydroMethod"] == 2:
+ sl_left = slice(None,-2,None)
+ sl_right = slice(1,-1,None)
+ div_fac = 1.0
+ else:
+ sl_left = slice(None,-2,None)
+ sl_right = slice(2,None,None)
+ div_fac = 2.0
+ new_field = na.zeros(data["Pressure"].shape, dtype='float64')
+ ds = div_fac * data['dx'].flat[0]
+ new_field[1:-1,1:-1,1:-1] = data["Pressure"][sl_right,1:-1,1:-1]/ds
+ new_field[1:-1,1:-1,1:-1] -= data["Pressure"][sl_left ,1:-1,1:-1]/ds
+ return new_field
+def _gradPressureY(field, data):
+ # We need to set up stencils
+ if data.pf["HydroMethod"] == 2:
+ sl_left = slice(None,-2,None)
+ sl_right = slice(1,-1,None)
+ div_fac = 1.0
+ else:
+ sl_left = slice(None,-2,None)
+ sl_right = slice(2,None,None)
+ div_fac = 2.0
+ new_field = na.zeros(data["Pressure"].shape, dtype='float64')
+ ds = div_fac * data['dy'].flat[0]
+ new_field[1:-1,1:-1,1:-1] = data["Pressure"][1:-1,sl_right,1:-1]/ds
+ new_field[1:-1,1:-1,1:-1] -= data["Pressure"][1:-1,sl_left ,1:-1]/ds
+ return new_field
+def _gradPressureZ(field, data):
+ # We need to set up stencils
+ if data.pf["HydroMethod"] == 2:
+ sl_left = slice(None,-2,None)
+ sl_right = slice(1,-1,None)
+ div_fac = 1.0
+ else:
+ sl_left = slice(None,-2,None)
+ sl_right = slice(2,None,None)
+ div_fac = 2.0
+ new_field = na.zeros(data["Pressure"].shape, dtype='float64')
+ ds = div_fac * data['dz'].flat[0]
+ new_field[1:-1,1:-1,1:-1] = data["Pressure"][1:-1,1:-1,sl_right]/ds
+ new_field[1:-1,1:-1,1:-1] -= data["Pressure"][1:-1,1:-1,sl_left ]/ds
+ return new_field
+def _convertgradPressure(data):
+ return 1.0/data.convert("cm")
+for ax in 'XYZ':
+ n = "gradPressure%s" % ax
+ add_field(n, function=eval("_%s" % n),
+ convert_function=_convertgradPressure,
+ validators=[ValidateSpatial(1, ["Pressure"])],
+ units=r"\rm{dyne}/\rm{cm}^{3}")
+
+def _gradPressureMagnitude(field, data):
+ return na.sqrt(data["gradPressureX"]**2 +
+ data["gradPressureY"]**2 +
+ data["gradPressureZ"]**2)
+add_field("gradPressureMagnitude", function=_gradPressureMagnitude,
+ validators=[ValidateSpatial(1, ["Pressure"])],
+ units=r"\rm{dyne}/\rm{cm}^{3}")
+
+def _gradDensityX(field, data):
+ # We need to set up stencils
+ if data.pf["HydroMethod"] == 2:
+ sl_left = slice(None,-2,None)
+ sl_right = slice(1,-1,None)
+ div_fac = 1.0
+ else:
+ sl_left = slice(None,-2,None)
+ sl_right = slice(2,None,None)
+ div_fac = 2.0
+ new_field = na.zeros(data["Density"].shape, dtype='float64')
+ ds = div_fac * data['dx'].flat[0]
+ new_field[1:-1,1:-1,1:-1] = data["Density"][sl_right,1:-1,1:-1]/ds
+ new_field[1:-1,1:-1,1:-1] -= data["Density"][sl_left ,1:-1,1:-1]/ds
+ return new_field
+def _gradDensityY(field, data):
+ # We need to set up stencils
+ if data.pf["HydroMethod"] == 2:
+ sl_left = slice(None,-2,None)
+ sl_right = slice(1,-1,None)
+ div_fac = 1.0
+ else:
+ sl_left = slice(None,-2,None)
+ sl_right = slice(2,None,None)
+ div_fac = 2.0
+ new_field = na.zeros(data["Density"].shape, dtype='float64')
+ ds = div_fac * data['dy'].flat[0]
+ new_field[1:-1,1:-1,1:-1] = data["Density"][1:-1,sl_right,1:-1]/ds
+ new_field[1:-1,1:-1,1:-1] -= data["Density"][1:-1,sl_left ,1:-1]/ds
+ return new_field
+def _gradDensityZ(field, data):
+ # We need to set up stencils
+ if data.pf["HydroMethod"] == 2:
+ sl_left = slice(None,-2,None)
+ sl_right = slice(1,-1,None)
+ div_fac = 1.0
+ else:
+ sl_left = slice(None,-2,None)
+ sl_right = slice(2,None,None)
+ div_fac = 2.0
+ new_field = na.zeros(data["Density"].shape, dtype='float64')
+ ds = div_fac * data['dz'].flat[0]
+ new_field[1:-1,1:-1,1:-1] = data["Density"][1:-1,1:-1,sl_right]/ds
+ new_field[1:-1,1:-1,1:-1] -= data["Density"][1:-1,1:-1,sl_left ]/ds
+ return new_field
+def _convertgradDensity(data):
+ return 1.0/data.convert("cm")
+for ax in 'XYZ':
+ n = "gradDensity%s" % ax
+ add_field(n, function=eval("_%s" % n),
+ convert_function=_convertgradDensity,
+ validators=[ValidateSpatial(1, ["Density"])],
+ units=r"\rm{g}/\rm{cm}^{4}")
+
+def _gradDensityMagnitude(field, data):
+ return na.sqrt(data["gradDensityX"]**2 +
+ data["gradDensityY"]**2 +
+ data["gradDensityZ"]**2)
+add_field("gradDensityMagnitude", function=_gradDensityMagnitude,
+ validators=[ValidateSpatial(1, ["Density"])],
+ units=r"\rm{g}/\rm{cm}^{4}")
+
+def _BaroclinicVorticityX(field, data):
+ rho2 = data["Density"].astype('float64')**2
+ return (data["gradPressureY"] * data["gradDensityZ"] -
+ data["gradPressureZ"] * data["gradDensityY"]) / rho2
+def _BaroclinicVorticityY(field, data):
+ rho2 = data["Density"].astype('float64')**2
+ return (data["gradPressureZ"] * data["gradDensityX"] -
+ data["gradPressureX"] * data["gradDensityZ"]) / rho2
+def _BaroclinicVorticityZ(field, data):
+ rho2 = data["Density"].astype('float64')**2
+ return (data["gradPressureX"] * data["gradDensityY"] -
+ data["gradPressureY"] * data["gradDensityX"]) / rho2
+for ax in 'XYZ':
+ n = "BaroclinicVorticity%s" % ax
+ add_field(n, function=eval("_%s" % n),
+ validators=[ValidateSpatial(1, ["Density", "Pressure"])],
+ units=r"\rm{s}^{-1}")
+
+def _BaroclinicVorticityMagnitude(field, data):
+ return na.sqrt(data["BaroclinicVorticityX"]**2 +
+ data["BaroclinicVorticityY"]**2 +
+ data["BaroclinicVorticityZ"]**2)
+add_field("BaroclinicVorticityMagnitude",
+ function=_BaroclinicVorticityMagnitude,
+ validators=[ValidateSpatial(1, ["Density", "Pressure"])],
+ units=r"\rm{s}^{-1}")
+
+def _VorticityX(field, data):
+ # We need to set up stencils
+ if data.pf["HydroMethod"] == 2:
+ sl_left = slice(None,-2,None)
+ sl_right = slice(1,-1,None)
+ div_fac = 1.0
+ else:
+ sl_left = slice(None,-2,None)
+ sl_right = slice(2,None,None)
+ div_fac = 2.0
+ new_field = na.zeros(data["z-velocity"].shape, dtype='float64')
+ new_field[1:-1,1:-1,1:-1] = (data["z-velocity"][1:-1,sl_right,1:-1] -
+ data["z-velocity"][1:-1,sl_left,1:-1]) \
+ / (div_fac*data["dy"].flat[0])
+ new_field[1:-1,1:-1,1:-1] -= (data["y-velocity"][1:-1,1:-1,sl_right] -
+ data["y-velocity"][1:-1,1:-1,sl_left]) \
+ / (div_fac*data["dz"].flat[0])
+ return new_field
+def _VorticityY(field, data):
+ # We need to set up stencils
+ if data.pf["HydroMethod"] == 2:
+ sl_left = slice(None,-2,None)
+ sl_right = slice(1,-1,None)
+ div_fac = 1.0
+ else:
+ sl_left = slice(None,-2,None)
+ sl_right = slice(2,None,None)
+ div_fac = 2.0
+ new_field = na.zeros(data["z-velocity"].shape, dtype='float64')
+ new_field[1:-1,1:-1,1:-1] = (data["x-velocity"][1:-1,1:-1,sl_right] -
+ data["x-velocity"][1:-1,1:-1,sl_left]) \
+ / (div_fac*data["dz"].flat[0])
+ new_field[1:-1,1:-1,1:-1] -= (data["z-velocity"][sl_right,1:-1,1:-1] -
+ data["z-velocity"][sl_left,1:-1,1:-1]) \
+ / (div_fac*data["dx"].flat[0])
+ return new_field
+def _VorticityZ(field, data):
+ # We need to set up stencils
+ if data.pf["HydroMethod"] == 2:
+ sl_left = slice(None,-2,None)
+ sl_right = slice(1,-1,None)
+ div_fac = 1.0
+ else:
+ sl_left = slice(None,-2,None)
+ sl_right = slice(2,None,None)
+ div_fac = 2.0
+ new_field = na.zeros(data["x-velocity"].shape, dtype='float64')
+ new_field[1:-1,1:-1,1:-1] = (data["y-velocity"][sl_right,1:-1,1:-1] -
+ data["y-velocity"][sl_left,1:-1,1:-1]) \
+ / (div_fac*data["dx"].flat[0])
+ new_field[1:-1,1:-1,1:-1] -= (data["x-velocity"][1:-1,sl_right,1:-1] -
+ data["x-velocity"][1:-1,sl_left,1:-1]) \
+ / (div_fac*data["dy"].flat[0])
+ return new_field
+def _convertVorticity(data):
+ return 1.0/data.convert("cm")
+for ax in 'XYZ':
+ n = "Vorticity%s" % ax
+ add_field(n, function=eval("_%s" % n),
+ convert_function=_convertVorticity,
+ validators=[ValidateSpatial(1,
+ ["x-velocity", "y-velocity", "z-velocity"])],
+ units=r"\rm{s}^{-1}")
+
+def _VorticityMagnitude(field, data):
+ return na.sqrt(data["VorticityX"]**2 +
+ data["VorticityY"]**2 +
+ data["VorticityZ"]**2)
+add_field("VorticityMagnitude", function=_VorticityMagnitude,
+ validators=[ValidateSpatial(1,
+ ["x-velocity", "y-velocity", "z-velocity"])],
+ units=r"\rm{s}^{-1}")
+
+def _VorticityStretchingX(field, data):
+ return data["DivV"] * data["VorticityX"]
+def _VorticityStretchingY(field, data):
+ return data["DivV"] * data["VorticityY"]
+def _VorticityStretchingZ(field, data):
+ return data["DivV"] * data["VorticityZ"]
+for ax in 'XYZ':
+ n = "VorticityStretching%s" % ax
+ add_field(n, function=eval("_%s" % n),
+ validators=[ValidateSpatial(0)])
+def _VorticityStretchingMagnitude(field, data):
+ return na.sqrt(data["VorticityStretchingX"]**2 +
+ data["VorticityStretchingY"]**2 +
+ data["VorticityStretchingZ"]**2)
+add_field("VorticityStretchingMagnitude",
+ function=_VorticityStretchingMagnitude,
+ validators=[ValidateSpatial(1,
+ ["x-velocity", "y-velocity", "z-velocity"])],
+ units=r"\rm{s}^{-1}")
+
+def _VorticityGrowthX(field, data):
+ return -data["VorticityStretchingX"] - data["BaroclinicVorticityX"]
+def _VorticityGrowthY(field, data):
+ return -data["VorticityStretchingY"] - data["BaroclinicVorticityY"]
+def _VorticityGrowthZ(field, data):
+ return -data["VorticityStretchingZ"] - data["BaroclinicVorticityZ"]
+for ax in 'XYZ':
+ n = "VorticityGrowth%s" % ax
+ add_field(n, function=eval("_%s" % n),
+ validators=[ValidateSpatial(1,
+ ["x-velocity", "y-velocity", "z-velocity"])],
+ units=r"\rm{s}^{-2}")
+def _VorticityGrowthMagnitude(field, data):
+ result = na.sqrt(data["VorticityGrowthX"]**2 +
+ data["VorticityGrowthY"]**2 +
+ data["VorticityGrowthZ"]**2)
+ dot = na.zeros(result.shape)
+ for ax in "XYZ":
+ dot += data["Vorticity%s" % ax] * data["VorticityGrowth%s" % ax]
+ result = na.sign(dot) * result
+ return result
+add_field("VorticityGrowthMagnitude", function=_VorticityGrowthMagnitude,
+ validators=[ValidateSpatial(1,
+ ["x-velocity", "y-velocity", "z-velocity"])],
+ units=r"\rm{s}^{-1}",
+ take_log=False)
+def _VorticityGrowthMagnitudeABS(field, data):
+ return na.sqrt(data["VorticityGrowthX"]**2 +
+ data["VorticityGrowthY"]**2 +
+ data["VorticityGrowthZ"]**2)
+add_field("VorticityGrowthMagnitudeABS", function=_VorticityGrowthMagnitudeABS,
+ validators=[ValidateSpatial(1,
+ ["x-velocity", "y-velocity", "z-velocity"])],
+ units=r"\rm{s}^{-1}")
+
+def _VorticityGrowthTimescale(field, data):
+ domegax_dt = data["VorticityX"] / data["VorticityGrowthX"]
+ domegay_dt = data["VorticityY"] / data["VorticityGrowthY"]
+ domegaz_dt = data["VorticityZ"] / data["VorticityGrowthZ"]
+ return na.sqrt(domegax_dt**2 + domegay_dt**2 + domegaz_dt)
+add_field("VorticityGrowthTimescale", function=_VorticityGrowthTimescale,
+ validators=[ValidateSpatial(1,
+ ["x-velocity", "y-velocity", "z-velocity"])],
+ units=r"\rm{s}")
+
+########################################################################
+# With radiation pressure
+########################################################################
+
+def _VorticityRadPressureX(field, data):
+ rho = data["Density"].astype('float64')
+ return (data["RadAccel2"] * data["gradDensityZ"] -
+ data["RadAccel3"] * data["gradDensityY"]) / rho
+def _VorticityRadPressureY(field, data):
+ rho = data["Density"].astype('float64')
+ return (data["RadAccel3"] * data["gradDensityX"] -
+ data["RadAccel1"] * data["gradDensityZ"]) / rho
+def _VorticityRadPressureZ(field, data):
+ rho = data["Density"].astype('float64')
+ return (data["RadAccel1"] * data["gradDensityY"] -
+ data["RadAccel2"] * data["gradDensityX"]) / rho
+def _convertRadAccel(data):
+ return data.convert("x-velocity")/data.convert("Time")
+for ax in 'XYZ':
+ n = "VorticityRadPressure%s" % ax
+ add_field(n, function=eval("_%s" % n),
+ convert_function=_convertRadAccel,
+ validators=[ValidateSpatial(1,
+ ["Density", "RadAccel1", "RadAccel2", "RadAccel3"])],
+ units=r"\rm{s}^{-1}")
+
+def _VorticityRadPressureMagnitude(field, data):
+ return na.sqrt(data["VorticityRadPressureX"]**2 +
+ data["VorticityRadPressureY"]**2 +
+ data["VorticityRadPressureZ"]**2)
+add_field("VorticityRadPressureMagnitude",
+ function=_VorticityRadPressureMagnitude,
+ validators=[ValidateSpatial(1,
+ ["Density", "RadAccel1", "RadAccel2", "RadAccel3"])],
+ units=r"\rm{s}^{-1}")
+
+def _VorticityRPGrowthX(field, data):
+ return -data["VorticityStretchingX"] - data["BaroclinicVorticityX"] \
+ -data["VorticityRadPressureX"]
+def _VorticityRPGrowthY(field, data):
+ return -data["VorticityStretchingY"] - data["BaroclinicVorticityY"] \
+ -data["VorticityRadPressureY"]
+def _VorticityRPGrowthZ(field, data):
+ return -data["VorticityStretchingZ"] - data["BaroclinicVorticityZ"] \
+ -data["VorticityRadPressureZ"]
+for ax in 'XYZ':
+ n = "VorticityRPGrowth%s" % ax
+ add_field(n, function=eval("_%s" % n),
+ validators=[ValidateSpatial(1,
+ ["Density", "RadAccel1", "RadAccel2", "RadAccel3"])],
+ units=r"\rm{s}^{-1}")
+def _VorticityRPGrowthMagnitude(field, data):
+ result = na.sqrt(data["VorticityRPGrowthX"]**2 +
+ data["VorticityRPGrowthY"]**2 +
+ data["VorticityRPGrowthZ"]**2)
+ dot = na.zeros(result.shape)
+ for ax in "XYZ":
+ dot += data["Vorticity%s" % ax] * data["VorticityGrowth%s" % ax]
+ result = na.sign(dot) * result
+ return result
+add_field("VorticityRPGrowthMagnitude", function=_VorticityGrowthMagnitude,
+ validators=[ValidateSpatial(1,
+ ["Density", "RadAccel1", "RadAccel2", "RadAccel3"])],
+ units=r"\rm{s}^{-1}",
+ take_log=False)
+def _VorticityRPGrowthMagnitudeABS(field, data):
+ return na.sqrt(data["VorticityRPGrowthX"]**2 +
+ data["VorticityRPGrowthY"]**2 +
+ data["VorticityRPGrowthZ"]**2)
+add_field("VorticityRPGrowthMagnitudeABS",
+ function=_VorticityRPGrowthMagnitudeABS,
+ validators=[ValidateSpatial(1,
+ ["Density", "RadAccel1", "RadAccel2", "RadAccel3"])],
+ units=r"\rm{s}^{-1}")
+
+def _VorticityRPGrowthTimescale(field, data):
+ domegax_dt = data["VorticityX"] / data["VorticityRPGrowthX"]
+ domegay_dt = data["VorticityY"] / data["VorticityRPGrowthY"]
+ domegaz_dt = data["VorticityZ"] / data["VorticityRPGrowthZ"]
+ return na.sqrt(domegax_dt**2 + domegay_dt**2 + domegaz_dt**2)
+add_field("VorticityRPGrowthTimescale", function=_VorticityRPGrowthTimescale,
+ validators=[ValidateSpatial(1,
+ ["Density", "RadAccel1", "RadAccel2", "RadAccel3"])],
+ units=r"\rm{s}^{-1}")
https://bitbucket.org/yt_analysis/yt/changeset/c0acbf8d4377/
changeset: c0acbf8d4377
branch: yt
user: jwise77
date: 2012-04-30 21:22:19
summary: Adding radiation fields and SN_Colour (Pop III metal field) to default
Enzo fields.
affected #: 1 file
diff -r fbd617f638f03d213dadbb58d706642136f3c285 -r c0acbf8d43778f223f414504048c0a3278bbfb24 yt/frontends/enzo/fields.py
--- a/yt/frontends/enzo/fields.py
+++ b/yt/frontends/enzo/fields.py
@@ -51,7 +51,7 @@
_speciesList = ["HI", "HII", "Electron",
"HeI", "HeII", "HeIII",
"H2I", "H2II", "HM",
- "DI", "DII", "HDI", "Metal", "PreShock"]
+ "DI", "DII", "HDI", "Metal", "MetalSNIa", "PreShock"]
_speciesMass = {"HI": 1.0, "HII": 1.0, "Electron": 1.0,
"HeI": 4.0, "HeII": 4.0, "HeIII": 4.0,
"H2I": 2.0, "H2II": 2.0, "HM": 1.0,
@@ -224,7 +224,10 @@
_default_fields = ["Density","Temperature",
"x-velocity","y-velocity","z-velocity",
"x-momentum","y-momentum","z-momentum",
- "Bx", "By", "Bz", "Dust_Temperature"]
+ "Bx", "By", "Bz", "Dust_Temperature",
+ "HI_kph", "HeI_kph", "HeII_kph", "H2I_kdiss", "PhotoGamma",
+ "RadAccel1", "RadAccel2", "RadAccel3", "SN_Colour",
+ "Ray_Segments"]
# else:
# _default_fields = ["Density","Temperature","Gas_Energy","Total_Energy",
# "x-velocity","y-velocity","z-velocity"]
@@ -247,11 +250,35 @@
f._units=r"\mathrm{Gau\ss}"
f.take_log=False
+def _convertkph(data):
+ return data.convert("Time")
+for field in ["HI_kph", "HeI_kph", "HeII_kph", "H2I_kdiss"]:
+ f = KnownEnzoFields[field]
+ f._convert_function = _convertkph
+ f._units=r"\rm{s}^{-1}"
+ f.take_log=True
+
+def _convertRadiationAccel(data):
+ return data.convert("cm") / data.convert("Time")
+for dim in range(1,4):
+ f = KnownEnzoFields["RadAccel%d" % dim]
+ f._convert_function = _convertRadiationAccel
+ f._units=r"\rm{cm}\ \rm{s}^{-2}"
+ f.take_log=False
+def _RadiationAccelerationMagnitude(field, data):
+ return ( data["RadAccel1"]**2 + data["RadAccel2"]**2 +
+ data["RadAccel3"]**2 )**(1.0/2.0)
+add_field("RadiationAcceleration",
+ function=_RadiationAccelerationMagnitude,
+ validators=ValidateDataField(["RadAccel1", "RadAccel2", "RadAccel3"]),
+ display_name="Radiation\ Acceleration", units=r"\rm{cm} \rm{s}^{-2}")
+
# Now we override
def _convertDensity(data):
return data.convert("Density")
-for field in ["Density"] + [ "%s_Density" % sp for sp in _speciesList ]:
+for field in ["Density"] + [ "%s_Density" % sp for sp in _speciesList ] + \
+ ["SN_Colour"]:
KnownEnzoFields[field]._units = r"\rm{g}/\rm{cm}^3"
KnownEnzoFields[field]._projected_units = r"\rm{g}/\rm{cm}^2"
KnownEnzoFields[field]._convert_function=_convertDensity
Repository URL: https://bitbucket.org/yt_analysis/yt/
--
This is a commit notification from bitbucket.org. You are receiving
this because you have the service enabled, addressing the recipient of
this email.
More information about the yt-svn
mailing list