/// Converts to Rankine from one of several unit systems. protected double ConvertToRankine(double t, eTemperature unit) { double targetTemp = 0; // in degrees Rankine switch (unit) { case eTemperature.eFahrenheit: targetTemp = t + 459.67; break; case eTemperature.eCelsius: targetTemp = (t + 273.15) * 1.8; break; case eTemperature.eRankine: targetTemp = t; break; case eTemperature.eKelvin: targetTemp = t * 1.8; break; default: break; } return(targetTemp); }
/// Converts from Rankine to one of several unit systems. protected double ConvertFromRankine(double t, eTemperature unit) { double targetTemp = 0; switch (unit) { case eTemperature.eFahrenheit: targetTemp = t - 459.67; break; case eTemperature.eCelsius: targetTemp = t / 1.8 - 273.15; break; case eTemperature.eRankine: targetTemp = t; break; case eTemperature.eKelvin: targetTemp = t / 1.8; break; default: break; } return(targetTemp); }
//@} // ************************************************************************* ///@name Humidity access functions //@{ /** Sets the dew point. * @param dewpoint The dew point in the units specified * @param unit The unit of measure that the specified dew point is supplied * in. */ public void SetDewPoint(eTemperature unit, double dewpoint) { double altitude = CalculatePressureAltitude(Pressure, 0.0); double VaporPressure = CalculateVaporPressure(ConvertToRankine(dewpoint, unit)); VaporMassFraction = Rdry * VaporPressure / (Rwater * (Pressure - VaporPressure)); ValidateVaporMassFraction(altitude); }
/// <summary> /// Sets the units presently specified for the model. /// </summary> /// <param name="forceUnits">The force units.</param> /// <param name="lengthUnits">The length units.</param> /// <param name="temperatureUnits">The temperature units.</param> public void SetPresentUnits(eForce forceUnits, eLength lengthUnits, eTemperature temperatureUnits) { _apiModel.SetPresentUnits(forceUnits, lengthUnits, temperatureUnits); UnitsForcePresent = forceUnits; UnitsLengthPresent = lengthUnits; UnitsTemperaturePresent = temperatureUnits; }
/// Returns the temperature bias over the sea level value in degrees Rankine. public virtual double GetTemperatureBias(eTemperature to) { if (to == eTemperature.eCelsius || to == eTemperature.eKelvin) { return(temperatureBias / 1.80); } else { return(temperatureBias); } }
/// Returns the temperature gradient to be applied on top of the standard /// temperature gradient. public virtual double GetTemperatureDeltaGradient(eTemperature to) { if (to == eTemperature.eCelsius || to == eTemperature.eKelvin) { return(temperatureDeltaGradient / 1.80); } else { return(temperatureDeltaGradient); } }
/// Sets the temperature bias to be added to the standard temperature at all /// altitudes. /// This function sets the bias - the difference - from the standard /// atmosphere temperature. This bias applies to the entire /// temperature profile. Another way to set the temperature bias is to use the /// SetSLTemperature function, which replaces the value calculated by /// this function with a calculated bias. /// @param t the temperature value in the unit provided. /// @param unit the unit of the temperature. public virtual void SetTemperatureBias(eTemperature unit, double t) { if (unit == eTemperature.eCelsius || unit == eTemperature.eKelvin) { t *= 1.80; // If temp delta "t" is given in metric, scale up to English } temperatureBias = t; CalculatePressureBreakpoints(SLpressure); SLtemperature = GetTemperature(0.0); CalculateSLSoundSpeedAndDensity(); }
public void SetBiomeFields(eMoisture moist, eTemperature temp, eBiome biome) { _moisture = moist; _temp = temp; _biome = biome; // for now, durability will just be a straight addition of moisture/temp // drier/colder means harder, moist/warm means softer int count = System.Enum.GetNames(typeof(eMoisture)).Length; _durability = (count - (int)moist) + (int)temp; }
/// Sets the temperature delta value at the supplied altitude/elevation above /// sea level, to be added to the standard temperature and ramped out by /// 86 km. /// This function computes the sea level delta from the standard atmosphere /// temperature at sea level. /// @param t the temperature skew value in the unit provided. /// @param unit the unit of the temperature. public virtual void SetTemperatureGradedDelta(double deltemp, double h, eTemperature unit = eTemperature.eFahrenheit) { if (unit == eTemperature.eCelsius || unit == eTemperature.eKelvin) { deltemp *= 1.80; // If temp delta "t" is given in metric, scale up to English } temperatureDeltaGradient = deltemp / (gradientFadeoutAltitude - GeopotentialAltitude(h)); CalculateLapseRates(); CalculatePressureBreakpoints(SLpressure); SLtemperature = GetTemperature(0.0); CalculateSLSoundSpeedAndDensity(); }
/// <summary> /// Sets the units presently specified for the model. /// </summary> /// <returns></returns> public void SetPresentUnits(eForce forceUnits, eLength lengthUnits, eTemperature temperatureUnits) { CSiProgram.eForce csiForceUnits = CSiProgram.eForce.NotApplicable; CSiProgram.eLength csiLengthUnits = CSiProgram.eLength.NotApplicable; CSiProgram.eTemperature csiTemperatureUnits = CSiProgram.eTemperature.NotApplicable; _callCode = _sapModel.SetPresentUnits_2(csiForceUnits, csiLengthUnits, csiTemperatureUnits); if (throwCurrentApiException(_callCode)) { throw new CSiException(); } }
/***************************************************/ public double DatabaseLengthUnitFactor() { eForce force = 0; eLength length = 0; eTemperature temp = 0; m_model.GetDatabaseUnits_2(ref force, ref length, ref temp); double factor = 1; switch (length) { case eLength.NotApplicable: Engine.Base.Compute.RecordWarning("Unknow NotApplicable unit, assumed to be meter."); factor = 1; break; case eLength.inch: factor = factor.ToInch(); break; case eLength.ft: factor = factor.ToFoot(); break; case eLength.micron: factor = factor.ToMicrometre(); break; case eLength.mm: factor = factor.ToMillimetre(); break; case eLength.cm: factor = factor.ToCentimetre(); break; case eLength.m: factor = 1; break; default: break; } return(factor); }
/** Returns the dew point. * @param to The unit of measure that the dew point should be supplied in. */ public double GetDewPoint(eTemperature to) { double dewpoint_degC; double VaporPressure = Pressure * VaporMassFraction / (VaporMassFraction + Rdry / Rwater); if (VaporPressure <= 0.0) { dewpoint_degC = -c; } else { double x = Math.Log(VaporPressure / a); dewpoint_degC = c * x / (b - x); } return(ConvertFromRankine(1.8 * (dewpoint_degC + 273.15), to)); }
/// Sets the temperature at the supplied altitude, if it is to be different /// than the standard temperature. /// This function will calculate a bias - a difference - from the standard /// atmosphere temperature at the supplied altitude and will apply that /// calculated bias to the entire temperature profile. If a graded delta is /// present, that will be included in the calculation - that is, regardless /// of any graded delta present, a temperature bias will be determined so that /// the temperature requested in this function call will be reached. /// @param t The temperature value in the unit provided. /// @param h The altitude in feet above sea level. /// @param unit The unit of the temperature. public override void SetTemperature(double t, double h, eTemperature unit = eTemperature.eFahrenheit) { double targetTemp = ConvertToRankine(t, unit); double GeoPotAlt = GeopotentialAltitude(h); temperatureBias = targetTemp - GetStdTemperature(h); if (GeoPotAlt <= gradientFadeoutAltitude) { temperatureBias -= temperatureDeltaGradient * (gradientFadeoutAltitude - GeoPotAlt); } CalculatePressureBreakpoints(SLpressure); SLtemperature = GetTemperature(0.0); CalculateSLSoundSpeedAndDensity(); }
/// <summary> /// Returns the units presently specified for the model. /// </summary> /// <returns></returns> public void GetPresentUnits(ref eForce forceUnits, ref eLength lengthUnits, ref eTemperature temperatureUnits) { CSiProgram.eForce csiForceUnits = CSiProgram.eForce.NotApplicable; CSiProgram.eLength csiLengthUnits = CSiProgram.eLength.NotApplicable; CSiProgram.eTemperature csiTemperatureUnits = CSiProgram.eTemperature.NotApplicable; _callCode = _sapModel.GetPresentUnits_2(ref csiForceUnits, ref csiLengthUnits, ref csiTemperatureUnits); if (throwCurrentApiException(_callCode)) { throw new CSiException(); } forceUnits = EnumLibrary.Convert(csiForceUnits, forceUnits); lengthUnits = EnumLibrary.Convert(csiLengthUnits, lengthUnits); temperatureUnits = EnumLibrary.Convert(csiTemperatureUnits, temperatureUnits); }
/// <summary> /// Returns the database units for the model. /// All data is internally stored in the model in these units and converted to the present units as needed. /// </summary> /// <returns></returns> public void GetDatabaseUnits(out eForce forceUnits, out eLength lengthUnits, out eTemperature temperatureUnits) { forceUnits = 0; lengthUnits = 0; temperatureUnits = 0; CSiProgram.eForce csiForceUnits = CSiProgram.eForce.NotApplicable; CSiProgram.eLength csiLengthUnits = CSiProgram.eLength.NotApplicable; CSiProgram.eTemperature csiTemperatureUnits = CSiProgram.eTemperature.NotApplicable; _callCode = _sapModel.GetDatabaseUnits_2(ref csiForceUnits, ref csiLengthUnits, ref csiTemperatureUnits); if (throwCurrentApiException(_callCode)) { throw new CSiException(API_DEFAULT_ERROR_CODE); } forceUnits = EnumLibrary.Convert(csiForceUnits, forceUnits); lengthUnits = EnumLibrary.Convert(csiLengthUnits, lengthUnits); temperatureUnits = EnumLibrary.Convert(csiTemperatureUnits, temperatureUnits); }
private eTemperature GetTempEnumFromValue(float value) { eTemperature t = eTemperature.Cold; if (value < 0.2f) { t = eTemperature.Hot; } else if (value < 0.4f) { t = eTemperature.Warm; } else if (value < 0.6f) { t = eTemperature.Normal; } else if (value < 0.8f) { t = eTemperature.Cool; } return(t); }
/// Sets the Sea Level temperature, if it is to be different than the /// standard. /// This function will calculate a bias - a difference - from the standard /// atmosphere temperature and will apply that bias to the entire /// temperature profile. This is one way to set the temperature bias. Using /// the SetTemperatureBias function will replace the value calculated by /// this function. /// @param t the temperature value in the unit provided. /// @param unit the unit of the temperature. public override void SetTemperatureSL(double t, eTemperature unit = eTemperature.eFahrenheit) { SetTemperature(t, 0.0, unit); }
// eTemperature internal static CSiProgram.eTemperature ToCSi(eTemperature enumValue) { return((CSiProgram.eTemperature)enumValue); }
public override void SetTemperature(double t, double h, eTemperature unit = eTemperature.eFahrenheit) { throw new NotImplementedException("Pending upgrade to lastest version of JSBSIM"); }
/// Sets a Sea Level temperature delta that is ramped out by 86 km. /// The value of the delta is used to calculate a delta gradient that is /// applied to the temperature at all altitudes below 86 km (282152 ft). /// For instance, if a temperature of 20 degrees F is supplied, the delta /// gradient would be 20/282152 - or, about 7.09E-5 degrees/ft. At sea level, /// the full 20 degrees would be added to the standard temperature, /// but that 20 degree delta would be reduced by 7.09E-5 degrees for every /// foot of altitude above sea level, so that by 86 km, there would be no /// further delta added to the standard temperature. /// The graded delta can be used along with the a bias to tailor the /// temperature profile as desired. /// @param t the sea level temperature delta value in the unit provided. /// @param unit the unit of the temperature. public virtual void SetSLTemperatureGradedDelta(eTemperature unit, double deltemp) { SetTemperatureGradedDelta(deltemp, 0.0, unit); }
/// Sets the Sea Level temperature. /// @param t the temperature value in the unit provided. /// @param unit the unit of the temperature. public virtual void SetTemperatureSL(double t, eTemperature unit = eTemperature.eFahrenheit) { SLtemperature = ConvertToRankine(t, unit); }
private void PopulateTiles(ref IslandData data, Vector3 terrainPos, float[][] moisture, float[][] temps, float[,] heights, int size, ref TerrainData tData) { GameObject container = new GameObject(); container.name = "Tile Colliders"; container.transform.SetParent(_currentTerrain.transform); container.transform.position = Vector3.zero; GameObject tileObject = null; Tile t = null; int tilesPerMeter = 3; //int[] offsets = new int[] { 0, 4, 7, 10, 13, 16, 19 }; //float[,,] splatData = new float[size, size, _terrainSplats.Length]; float subTileOffset = 1 / (float)tilesPerMeter; Vector3 offsetPosition = new Vector3(0f, 0.05f, 0f); for (int i = 0; i < size; ++i) { for (int j = 0; j < size; ++j) { float height = heights[j, i]; // don't put tiles on the bottom most layer if (height > 0f) { int terrainX, terrainY; GetWorldTerrainPosition(terrainPos, i, j, out terrainX, out terrainY); GameObject tileContainer = new GameObject(); tileContainer.name = string.Format("Tile[{0},{1}]", i, j); tileContainer.transform.SetParent(container.transform); tileContainer.transform.position = Vector3.zero; // for multiple tiles per meter for (int k = 0; k < tilesPerMeter; ++k) { for (int l = 0; l < tilesPerMeter; ++l) { // create physical tile offsetPosition.x = (subTileOffset / 2f) + subTileOffset * k; offsetPosition.z = (subTileOffset / 2f) + subTileOffset * l; tileObject = (GameObject)Instantiate(_tilePrefab); tileObject.name = string.Format("Sub Tile[{0},{1}]", k, l); t = tileObject.AddComponent <Tile>(); t.Init(i, j, height, terrainX + offsetPosition.z, terrainY + offsetPosition.x); tileObject.transform.position = t.WorldPosition; // add to parent container for a neat hierarchy tileObject.transform.SetParent(tileContainer.transform); } } // determine biome eMoisture moist = GetMoistureEnumFromValue(moisture[i][j]); eTemperature temp = GetTempEnumFromValue(temps[i][j]); eBiome biome = _biomeTable[(int)moist, (int)temp]; t.SetBiomeFields(moist, temp, biome); // set terrain texture //int textureIndex = offsets[(int)biome] + (int)eTileType.Grass; //splatData[j, i, textureIndex] = 1; } else { // just dirt if height is zero //int textureIndex = offsets[(int)eBiome.Jungle] + (int)eTileType.Dirt; //splatData[j, i, textureIndex] = 1; } // need to fill the island data with values, even if no tile is actually created data.AddTile(t, i, j); } } //tData.SetAlphamaps(0, 0, splatData); }
public void SetPresentUnits(eForce forceUnits, eLength lengthUnits, eTemperature temperatureUnits) { }
/// Sets the temperature at the supplied altitude. /// @param t The temperature value in the unit provided. /// @param h The altitude in feet above sea level. /// @param unit The unit of the temperature. public abstract void SetTemperature(double t, double h, eTemperature unit = eTemperature.eFahrenheit);
public void GetPresentUnits(ref eForce forceUnits, ref eLength lengthUnits, ref eTemperature temperatureUnits) { Assert.IsTrue(false); }
public void PlaceTile(float x, float z, ref IslandData data, Vector3 terrainPos) { TerrainData tData = data.Data; float[,] heights = tData.GetHeights(0, 0, data.Size, data.Size); int tilesPerMeter = 3; float subTileOffset = 1 / (float)tilesPerMeter; Vector3 offsetPosition = new Vector3(0f, 0.05f, 0f); int i = Mathf.RoundToInt(x); int j = Mathf.RoundToInt(z); if (_tileContainer == null) { _tileContainer = new GameObject("Tile Container"); _tileContainer.transform.SetParent(_currentTerrain.transform); _tileContainer.transform.localPosition = Vector3.zero; } float height = heights[j, i]; GameObject tileObject = null; Tile t = null; // don't put tiles on the bottom most layer if (height > 0f) { int terrainX, terrainY; GetWorldTerrainPosition(terrainPos, i, j, out terrainX, out terrainY); // TODO this will need to be removed and only 1 tile be placed; not all 9 //for multiple tiles per meter for (int k = 0; k < tilesPerMeter; ++k) { for (int l = 0; l < tilesPerMeter; ++l) { // create physical tile offsetPosition.x = (subTileOffset / 2f) + subTileOffset * k; offsetPosition.z = (subTileOffset / 2f) + subTileOffset * l; tileObject = (GameObject)Instantiate(_tilePrefab); tileObject.name = string.Format("Sub Tile[{0},{1}]", k, l); t = tileObject.AddComponent <Tile>(); t.Init(i, j, height, terrainX + offsetPosition.z, terrainY + offsetPosition.x); tileObject.transform.position = t.WorldPosition; // add to parent container for a neat hierarchy tileObject.transform.SetParent(_tileContainer.transform); } } // determine biome eMoisture moist = eMoisture.Wet; //GetMoistureEnumFromValue(moisture[i][j]); eTemperature temp = eTemperature.Normal; //GetTempEnumFromValue(temps[i][j]); eBiome biome = _biomeTable[(int)moist, (int)temp]; t.SetBiomeFields(moist, temp, biome); // set terrain texture //int textureIndex = offsets[(int)biome] + (int)eTileType.Grass; //splatData[j, i, textureIndex] = 1; } else { // just dirt if height is zero //int textureIndex = offsets[(int)eBiome.Jungle] + (int)eTileType.Dirt; //splatData[j, i, textureIndex] = 1; } // need to fill the island data with values, even if no tile is actually created data.AddTile(t, i, j); }