///API-No.1
/// <summary>
/// 设置眼镜进入模式,运行过程中可修改
/// </summary>
public static void SetTrackMode(TrackMode mode)
{
if (SvrManager.Instance != null)
{
SvrManager.Instance.settings.trackPosition = (mode == TrackMode.Mode_6Dof ? true : false);
}
}
public TrackHistory(int x, int y, TrackSlope slope)
{
X = (short)x;
Y = (short)y;
Slope = slope;
Mode = TrackMode.Normal;
}
// Get tracked target *position* (at which light should point)
Vector3?GetTrackTarget(TrackMode mode)
{
switch (mode)
{
case TrackMode.ActiveVessel:
{
if (vessel == FlightGlobals.ActiveVessel)
{
return(null);
}
return(FlightGlobals.ActiveVessel?.transform.position);
}
case TrackMode.TargetVessel:
{
if (vessel == vessel?.targetObject?.GetVessel())
{
return(null);
}
return(vessel?.targetObject?.GetTransform().position);
}
default:
return(null);
}
}
// Calculate manages calculations that need to be run for each time step
public void Calculate
(
double SunZenith // The Zenith position of the sun with 0 being normal to the earth [radians]
, double SunAzimuth // The Azimuth position of the sun relative to 0 being true south. Positive if west, negative if east [radians]
, double PanelTilt // The angle between the surface tilt of the module and the ground [radians]
, double PanelAzimuth // The azimuth direction in which the surface is facing. Positive if west, negative if east [radians]
, double POABeam // The amount of direct irradiance incident on the panel [W/m^2]
, double POADiff // The amount of diffuse irradiance incident on the panel [W/m^2]
, double POAGRef // The amount of ground reflected irradianc incident on the panel [W/m^2]
, double HBeam // The amount of direct irradiance incident on a horizontally oriented detector [W/m^2]
, double HDiff // The amount of diffuse irradiance incident on a horizontally oriented detector [W/m^2]
, TrackMode ArrayTrackMode // The tracking mode, used to determine whether to calculate the diffuse factor in Config or Calculate
)
{
// If the user inputs POA irradiance data, it is assumed to already account for horizon
// If the horizon is either not defined or is 0, the horizon calculations do not need to be carried out
// The horizon shaded irradiance factors are then assumed to be 1, therefore the horizon shaded irradiance is the same as that output by the tilter class
if (ReadFarmSettings.UsePOA == true || horizonDefined != true)
{
TDir = POABeam;
TDif = POADiff;
TRef = POAGRef;
TGlo = TDir + TDif + TRef;
}
else
{
// If there is no tracking, these calculations are taken care of in Config
if (ArrayTrackMode != TrackMode.NOAT)
{
// The full azimuthal range of the Horizon Profile is filled in using Interpolation
HorizonAzimInterpolated = InitializeHorizonProfile(PanelAzimuth);
HorizonElevInterpolated = GetInterpolatedElevationProfile(HorizonAzimExtended, HorizonElevExtended, HorizonAzimInterpolated);
// Calculates the limiting angle array
LimitingAngle = GetLimitingAngleArray(PanelTilt, PanelAzimuth, HorizonAzimInterpolated);
// The shading factor is calculated via numerical computation using the mathematical models described in the CASSYS documentation
DiffFactor = GetHorizonDiffuseFactor(PanelTilt, PanelAzimuth, HorizonAzimInterpolated, HorizonElevInterpolated, LimitingAngle);
}
BeamFactor = GetHorizonBeamFactor(SunAzimuth, SunZenith, HorizonAzimInterpolated, HorizonElevInterpolated, PanelAzimuth);
GRefFactor = GetHorizonGRefFactor(BeamFactor, RefDiffFactor, HBeam, HDiff);
// The horizon shaded irradiance values are those multiplied by the horizon shading factors
TDir = BeamFactor * POABeam;
TDif = DiffFactor * POADiff;
TRef = GRefFactor * POAGRef;
TGlo = TDir + TDif + TRef;
}
// Calculate horizon shading losses
LossDir = POABeam - TDir;
LossDif = POADiff - TDif;
LossRef = POAGRef - TRef;
LossGlo = LossDir + LossDif + LossRef;
}
// Config takes values from the xml as well as manages calculations that need only to be run once
public void Config
(
double PanelTiltFixed // The tilt of the panel, used in config if no tracking is selected [radians]
, double PanelAzimFixed // The azimuth position of the panel, used in config if no tracking is selected [radians]
, TrackMode ArrayTrackMode // The tracking mode, used to determine whether the diffuse fraction can be calculated in config
)
{
// Loads the Horizon Profile from the .csyx document
horizonDefined = Convert.ToBoolean(ReadFarmSettings.GetInnerText("O&S", "DefineHorizonProfile", ErrLevel.WARNING, _default: "false"));
if (horizonDefined == true)
{
// Getting the horizon information from the .csyx file
HorizonDefinitionAzimStr = ReadFarmSettings.GetInnerText("O&S", "HorizonAzi", ErrLevel.WARNING, "0.9", _default: "0");
HorizonDefinitionElevStr = ReadFarmSettings.GetInnerText("O&S", "HorizonElev", ErrLevel.WARNING, "0.9", _default: "0");
// Converts the Horizon Profile imported from the.csyx document into an array of doubles
HorizonAzim = HorizonCSVStringtoArray(HorizonDefinitionAzimStr);
HorizonElev = HorizonCSVStringtoArray(HorizonDefinitionElevStr);
// If user inputs horizon azimuth/elevation data of two different lengths
if (HorizonAzim.Length != HorizonElev.Length)
{
ErrorLogger.Log("The number of horizon azimuth values is not equal to the number of horizon elevation values.", ErrLevel.FATAL);
}
// Extends the Horizon Profile by duplicating the first and last values and transposing them 360 degrees forward and backwards, respectively
CalcExtendedHorizon(HorizonAzim, HorizonElev, out HorizonAzimExtended, out HorizonElevExtended);
// The full azimuthal range of the Horizon Profile is filled in using Interpolation
// The horizon profile must be calculated here both for the non-tracking case, as well as for the ground reflected diffuse factor for all tracking cases
// It is calculated separately in the Calculate method for tracking cases
HorizonAzimInterpolated = InitializeHorizonProfile(PanelAzimFixed);
HorizonElevInterpolated = GetInterpolatedElevationProfile(HorizonAzimExtended, HorizonElevExtended, HorizonAzimInterpolated);
// If there is no tracking implemented the diffuse horizon factor only needs to be calculated once, it is otherwise calculated in the Calculate method
if (ArrayTrackMode == TrackMode.NOAT && ReadFarmSettings.UsePOA != true)
{
// Calculates the limiting angle array
LimitingAngle = GetLimitingAngleArray(PanelTiltFixed, PanelAzimFixed, HorizonAzimInterpolated);
// The shading factor is calculated via numerical computation using the mathematical models described in the CASSYS documentation
DiffFactor = GetHorizonDiffuseFactor(PanelTiltFixed, PanelAzimFixed, HorizonAzimInterpolated, HorizonElevInterpolated, LimitingAngle);
}
// Creating the limiting angle array for the ground, all values are PI/2
RefLimitingAngle = new double[361];
for (int i = 0; i < RefLimitingAngle.Length; i++)
{
RefLimitingAngle[i] = Math.PI / 2;
}
// Diffuse part of ground reflected factor only needs to be calculated once. 0s are used for azimuth and tilt of surface, as it represents the ground.
RefDiffFactor = GetHorizonDiffuseFactor(0, 0, HorizonAzimInterpolated, HorizonElevInterpolated, RefLimitingAngle);
}
}
private void InitializeMap()
{
TrackMode = TrackMode.None;
mapControl.MapClick += WpfMap1_MapClick;
mapControl.MapUnit = GeographyUnit.Meter;
mapControl.CurrentExtent = defaultExtent;
InitializeMapTools();
InitializeOverlays();
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
TrackMode layerName = (TrackMode)value;
if (mapControlModes.ContainsKey(layerName))
{
return(mapControlModes[layerName]);
}
return(null);
}
public void SetFlag(TrackMode mode, bool flag)
{
if (flag)
{
this.mode |= mode;
}
else
{
this.mode &= ~(mode);
}
}
public static void SetTrackMode(this TrackInteractiveOverlay trackOverlay, TrackMode mode)
{
if (trackOverlay.TrackMode != mode)
{
trackOverlay.TrackMode = mode;
if (mode == TrackMode.Polygon || mode == TrackMode.Line || mode == TrackMode.Point || mode == TrackMode.Multipoint)
{
SetStyle(trackOverlay.TrackShapeLayer);
}
}
}
public HSFMotionGroupText(AnimationNode group)
{
Name = group.Name;
ValueIndex = group.ValueIndex;
Mode = group.Mode;
foreach (AnimTrack track in group.GetTracks())
{
Tracks.Add(new HSFMotionTrackText(track));
}
}
private void InitializeMap()
{
TrackMode = TrackMode.None;
mapControl.MapClick += WpfMap1_MapClick;
mapControl.MapUnit = GeographyUnit.Meter;
mapControl.ZoomLevelSet = new ThinkGeoCloudMapsZoomLevelSet();
mapControl.CurrentExtent = defaultExtent;
InitializeMapTools();
InitializeOverlays();
}
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
{
if (values.Length == 2 && values[0] is TrackMode && values[1] is MapControl)
{
TrackMode trackMode = (TrackMode)values[0];
MapControl mapControl = (MapControl)values[1];
return(mapControl.Behaviors.TrackBehavior.TrackMode == trackMode);
}
else
{
return(Binding.DoNothing);
}
}
private string LabelFor(TrackMode mode)
{
switch (mode)
{
case TrackMode.ActiveVessel:
return("Active vessel");
case TrackMode.TargetVessel:
return("Target vessel");
default:
throw new ArgumentOutOfRangeException(nameof(mode));
}
}
private void SetTrackFlag(TrackMode mode, bool v)
{
var tree = SeqenceWindow.inst.tree;
var tracks = tree.AllSelectTracks();
if (tracks.Count > 1)
{
tracks.ForEach(x => x.track.SetFlag(mode, v));
}
else
{
track.SetFlag(mode, v);
}
SeqenceWindow.inst.Repaint();
}
private static TrackEffect ParseEffect(TrackMode mode, string value)
{
if (mode == TrackMode.Attriubute)
{
return((TrackEffect)Enum.Parse(typeof(AttributeTrackEffect), value));
}
if (mode == TrackMode.Material)
{
return((TrackEffect)Enum.Parse(typeof(MaterialTrackEffect), value));
}
else
{
return((TrackEffect)Enum.Parse(typeof(TrackEffect), value));
}
}
private void CancelDrawingMenuItem_Click(object sender, MouseButtonEventArgs e)
{
TrackMode tmpTrackMode = GisEditor.ActiveMap.TrackOverlay.TrackMode;
GisEditor.ActiveMap.TrackOverlay.TrackMode = TrackMode.None;
GisEditor.ActiveMap.TrackOverlay.TrackMode = tmpTrackMode;
var circle = GisEditor.ActiveMap.TrackOverlay.OverlayCanvas.Children.OfType <System.Windows.Shapes.Ellipse>().FirstOrDefault();
if (circle != null)
{
GisEditor.ActiveMap.TrackOverlay.OverlayCanvas.Children.Remove(circle);
}
EditingToolsViewModel.Instance.CancelCommand.Execute(null);
}
private void SetTrackFlag(TrackMode mode, bool v)
{
var tree = TimelineWindow.inst.tree;
var tracks = tree.AllSelectTracks();
if (tracks.Count > 1)
{
foreach (var track in tracks)
{
track.track.SetFlag(mode, v);
}
}
else
{
track.SetFlag(mode, v);
}
TimelineWindow.inst.Repaint();
}
static TrackType TrackModeToTrackType(TrackMode trackType)
{
switch (trackType)
{
case TrackMode.Mode1: return(TrackType.CdMode1);
case TrackMode.Mode2F1:
case TrackMode.Mode2F1Alt: return(TrackType.CdMode2Form1);
case TrackMode.Mode2F2:
case TrackMode.Mode2F2Alt: return(TrackType.CdMode2Form2);
case TrackMode.Mode2: return(TrackType.CdMode2Formless);
case TrackMode.Audio: return(TrackType.Audio);
default: return(TrackType.Data);
}
}
static ushort TrackModeToCookedBytesPerSector(TrackMode trackMode)
{
switch (trackMode)
{
case TrackMode.Mode1:
case TrackMode.Mode2F1:
case TrackMode.Mode2F1Alt: return(2048);
case TrackMode.Mode2F2:
case TrackMode.Mode2F2Alt: return(2324);
case TrackMode.Mode2: return(2336);
case TrackMode.Audio: return(2352);
case TrackMode.DVD: return(2048);
default: return(0);
}
}
public virtual void OnDestroy()
{
Foreach(track => track.OnDestroy(), clip => clip.OnDestroy());
ForeachMark(mark => mark.OnDestroy());
childs = null;
marks = null;
parent = null;
clips = null;
mode = 0;
if (mixs != null)
{
for (int i = 0; i < mixs.Count; i++)
{
SharedPool <MixClip> .Return(mixs[i]);
}
mixs.Clear();
mixs = null;
}
}
private void InitializeMap()
{
TrackMode = TrackMode.None;
mapControl.MapClick += WpfMap1_MapClick;
mapControl.MapUnit = GeographyUnit.Meter;
mapControl.CurrentExtent = defaultExtent;
InitializeMapTools();
InitializeOverlays();
}
public TrackModeViewModel(string name, TrackMode mode, string imagePath)
{
this.name = name;
this.mode = mode;
this.imagePath = imagePath;
}
public void CycleTrackMode()
{
SelectedTrackMode = SelectedTrackMode.Next();
UpdateTrackModeControl();
}
// Config manages calculations and initializations that need only to be run once
public void Config()
{
bool useBifacial = Convert.ToBoolean(ReadFarmSettings.GetInnerText("Bifacial", "UseBifacialModel", ErrLevel.FATAL));
if (useBifacial)
{
// Number of segments into which to divide up the ground [#]
numGroundSegs = Util.NUM_GROUND_SEGS;
switch (ReadFarmSettings.GetAttribute("O&S", "ArrayType", ErrLevel.FATAL))
{
// In all cases, pitch and clearance must be normalized to panel slope lengths
case "Fixed Tilted Plane":
itsTrackMode = TrackMode.NOAT;
if (String.Compare(ReadFarmSettings.CASSYSCSYXVersion, "0.9.3") >= 0)
{
itsPanelTilt = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "PlaneTiltFix", ErrLevel.FATAL));
}
else
{
itsPanelTilt = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "PlaneTilt", ErrLevel.FATAL));
}
// itsPitch will be assigned in the below (numRows == 1) conditional
itsArrayBW = Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "CollBandWidthFix", ErrLevel.FATAL));
itsClearance = Convert.ToDouble(ReadFarmSettings.GetInnerText("Bifacial", "GroundClearance", ErrLevel.FATAL)) / itsArrayBW;
numRows = 1;
break;
case "Unlimited Rows":
itsTrackMode = TrackMode.NOAT;
itsPanelTilt = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "PlaneTilt", ErrLevel.FATAL));
itsArrayBW = Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "CollBandWidth", ErrLevel.FATAL));
itsPitch = Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "Pitch", ErrLevel.FATAL)) / itsArrayBW;
itsClearance = Convert.ToDouble(ReadFarmSettings.GetInnerText("Bifacial", "GroundClearance", ErrLevel.FATAL)) / itsArrayBW;
numRows = int.Parse(ReadFarmSettings.GetInnerText("O&S", "RowsBlock", ErrLevel.FATAL));
break;
case "Single Axis Elevation Tracking (E-W)":
itsTrackMode = TrackMode.SAXT;
itsArrayBW = Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "WActiveSAET", ErrLevel.FATAL));
itsPitch = Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "PitchSAET", ErrLevel.FATAL)) / itsArrayBW;
numRows = int.Parse(ReadFarmSettings.GetInnerText("O&S", "RowsBlockSAET", ErrLevel.FATAL));
break;
case "Single Axis Horizontal Tracking (N-S)":
itsTrackMode = TrackMode.SAXT;
itsArrayBW = Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "WActiveSAST", ErrLevel.FATAL));
itsPitch = Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "PitchSAST", ErrLevel.FATAL)) / itsArrayBW;
numRows = int.Parse(ReadFarmSettings.GetInnerText("O&S", "RowsBlockSAST", ErrLevel.FATAL));
break;
default:
ErrorLogger.Log("Bifacial is not supported for the selected orientation and shading.", ErrLevel.FATAL);
break;
}
transFactor = Convert.ToDouble(ReadFarmSettings.GetInnerText("Bifacial", "PanelTransFactor", ErrLevel.FATAL));
if (numRows == 1)
{
// Pitch is needed for a single row because of ground patch calculations and geometry. Take value 100x greater than array bandwidth.
itsPitch = 100;
itsRowType = RowType.SINGLE;
}
else
{
itsRowType = RowType.INTERIOR;
}
// Initialize arrays
frontGroundSH = new int[numGroundSegs];
rearGroundSH = new int[numGroundSegs];
frontSkyViewFactors = new double[numGroundSegs];
rearSkyViewFactors = new double[numGroundSegs];
frontGroundGHI = new double[numGroundSegs];
rearGroundGHI = new double[numGroundSegs];
// Calculate sky view factors for diffuse shading. Stays constant for non-tracking systems, so done here in Config()
if (itsTrackMode == TrackMode.NOAT)
{
CalcSkyViewFactors();
}
}
}
private void InitializeProperties()
{
queryFilter = new EarthquakeQueryFilter();
queryResults = new Collection<EarthquakeViewModel>();
displayTypes = new ObservableCollection<FeatureLayerViewModel>();
filteredQueryResults = new ObservableCollection<EarthquakeViewModel>();
SelectedMapMode = MapControlModes.FirstOrDefault();
foreach (FeatureLayer featureLayer in mapModel.StyleLayerOverlay.Layers.OfType<FeatureLayer>())
{
DisplayTypes.Add(new FeatureLayerViewModel(featureLayer));
}
SelectedFeatureLayer = DisplayTypes.FirstOrDefault();
}
protected XTrack()
{
ID = XSeqence.IncID;
mode = TrackMode.Normal;
}
// Gathering the tracker mode, and relevant operational limits, and tracking axis characteristics.
public void Config()
{
switch (ReadFarmSettings.GetAttribute("O&S", "ArrayType", ErrLevel.FATAL))
{
case "Fixed Tilted Plane":
itsTrackMode = TrackMode.NOAT;
if (String.Compare(ReadFarmSettings.CASSYSCSYXVersion, "0.9.3") >= 0)
{
SurfSlope = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "PlaneTiltFix", ErrLevel.FATAL));
SurfAzimuth = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "AzimuthFix", ErrLevel.FATAL));
}
else
{
SurfSlope = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "PlaneTilt", ErrLevel.FATAL));
SurfAzimuth = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "Azimuth", ErrLevel.FATAL));
}
break;
case "Fixed Tilted Plane Seasonal Adjustment":
itsTrackMode = TrackMode.FTSA;
SurfAzimuth = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "AzimuthSeasonal", ErrLevel.FATAL));
itsSummerMonth = DateTime.ParseExact(ReadFarmSettings.GetInnerText("O&S", "SummerMonth", _Error: ErrLevel.FATAL), "MMM", CultureInfo.CurrentCulture).Month;
itsWinterMonth = DateTime.ParseExact(ReadFarmSettings.GetInnerText("O&S", "WinterMonth", _Error: ErrLevel.FATAL), "MMM", CultureInfo.CurrentCulture).Month;
itsSummerDay = int.Parse(ReadFarmSettings.GetInnerText("O&S", "SummerDay", _Error: ErrLevel.FATAL));
itsWinterDay = int.Parse(ReadFarmSettings.GetInnerText("O&S", "WinterDay", _Error: ErrLevel.FATAL));
itsPlaneTiltSummer = Util.DTOR * double.Parse(ReadFarmSettings.GetInnerText("O&S", "PlaneTiltSummer", _Error: ErrLevel.FATAL));
itsPlaneTiltWinter = Util.DTOR * double.Parse(ReadFarmSettings.GetInnerText("O&S", "PlaneTiltWinter", _Error: ErrLevel.FATAL));
// Assume the simualtion will begin when the array is in the summer tilt
SurfSlope = itsPlaneTiltSummer;
break;
case "Unlimited Rows":
itsTrackMode = TrackMode.NOAT;
// Defining all the parameters for the shading of a unlimited row array configuration
SurfSlope = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "PlaneTilt", ErrLevel.FATAL));
SurfAzimuth = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "Azimuth", ErrLevel.FATAL));
break;
case "Single Axis Elevation Tracking (E-W)":
// Tracker Parameters
itsTrackMode = TrackMode.SAXT;
itsTrackerAzimuth = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "AxisAzimuthSAET", ErrLevel.FATAL));
itsTrackerSlope = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "AxisTiltSAET", ErrLevel.FATAL));
// Operational Limits
itsMinTilt = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "MinTiltSAET", ErrLevel.FATAL));
itsMaxTilt = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "MaxTiltSAET", ErrLevel.FATAL));
// Backtracking Options
useBackTracking = Convert.ToBoolean(ReadFarmSettings.GetInnerText("O&S", "BacktrackOptSAET", ErrLevel.WARNING, _default: "false"));
if (useBackTracking)
{
itsTrackerPitch = Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "PitchSAET", ErrLevel.FATAL));
itsTrackerBW = Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "WActiveSAET", ErrLevel.FATAL));
}
break;
case "Single Axis Horizontal Tracking (N-S)":
// Tracker Parameters
itsTrackMode = TrackMode.SAXT;
itsTrackerSlope = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "AxisTiltSAST", ErrLevel.FATAL));
itsTrackerAzimuth = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "AxisAzimuthSAST", ErrLevel.FATAL));
// Operational Limits
itsMaxTilt = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "RotationMaxSAST", ErrLevel.FATAL));
// Backtracking Options
useBackTracking = Convert.ToBoolean(ReadFarmSettings.GetInnerText("O&S", "BacktrackOptSAST", ErrLevel.WARNING, _default: "false"));
if (useBackTracking)
{
itsTrackerPitch = Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "PitchSAST", ErrLevel.FATAL));
itsTrackerBW = Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "WActiveSAST", ErrLevel.FATAL));
}
break;
case "Tilt and Roll Tracking":
// Tracker Parameters
itsTrackMode = TrackMode.SAXT;
itsTrackerSlope = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "AxisTiltTART", ErrLevel.FATAL));
itsTrackerAzimuth = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "AxisAzimuthTART", ErrLevel.FATAL));
// Operational Limits
itsMinRotationAngle = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "RotationMinTART", ErrLevel.FATAL));
itsMaxRotationAngle = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "RotationMaxTART", ErrLevel.FATAL));
break;
case "Two Axis Tracking":
itsTrackMode = TrackMode.TAXT;
// Operational Limits
itsMinTilt = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "MinTiltTAXT", ErrLevel.FATAL));
itsMaxTilt = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "MaxTiltTAXT", ErrLevel.FATAL));
itsAzimuthRef = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "AzimuthRefTAXT", ErrLevel.FATAL));
itsMinAzimuth = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "MinAzimuthTAXT", ErrLevel.FATAL));
itsMaxAzimuth = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "MaxAzimuthTAXT", ErrLevel.FATAL));
break;
case "Azimuth (Vertical Axis) Tracking":
itsTrackMode = TrackMode.AVAT;
// Surface Parameters
SurfSlope = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "PlaneTiltAVAT", ErrLevel.FATAL));
// Operational Limits
itsAzimuthRef = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "AzimuthRefAVAT", ErrLevel.FATAL));
itsMinAzimuth = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "MinAzimuthAVAT", ErrLevel.FATAL));
itsMaxAzimuth = Util.DTOR * Convert.ToDouble(ReadFarmSettings.GetInnerText("O&S", "MaxAzimuthAVAT", ErrLevel.FATAL));
break;
default:
ErrorLogger.Log("No orientation and shading was specified by the user.", ErrLevel.FATAL);
break;
}
}
public bool GetFlag(TrackMode mode)
{
return((this.mode & mode) > 0);
}
private void AppendToHistory(TrackSlope slope, TrackMode mode = TrackMode.Normal)
{
_history[_length] = new TrackHistory(_history[_length - 1].X + _xDirection, (int)_history[_length - 1].Y + (int)slope, slope);
_history[_length].Mode = mode;
_length++;
}
protected XTrack()
{
ID = XTimeline.IncID;
mode = TrackMode.Normal;
}
