/// <summary>
/// Unbind the behavior.
/// </summary>
public override void Unbind()
{
base.Unbind();
// Get matrix pointers
DrainDrainPtr = null;
GateGatePtr = null;
SourceSourcePtr = null;
BulkBulkPtr = null;
DrainPrimeDrainPrimePtr = null;
SourcePrimeSourcePrimePtr = null;
DrainDrainPrimePtr = null;
GateBulkPtr = null;
GateDrainPrimePtr = null;
GateSourcePrimePtr = null;
SourceSourcePrimePtr = null;
BulkDrainPrimePtr = null;
BulkSourcePrimePtr = null;
DrainPrimeSourcePrimePtr = null;
DrainPrimeDrainPtr = null;
BulkGatePtr = null;
DrainPrimeGatePtr = null;
SourcePrimeGatePtr = null;
SourcePrimeSourcePtr = null;
DrainPrimeBulkPtr = null;
SourcePrimeBulkPtr = null;
SourcePrimeDrainPrimePtr = null;
// Get rhs pointers
BulkPtr = null;
DrainPrimePtr = null;
SourcePrimePtr = null;
}
/// <summary>
/// Bind behavior.
/// </summary>
/// <param name="simulation">The simulation.</param>
/// <param name="context">Data provider</param>
public override void Bind(Simulation simulation, BindingContext context)
{
base.Bind(simulation, context);
// Get parameters
BaseParameters = context.GetParameterSet <CommonBehaviors.IndependentSourceParameters>();
// Setup the waveform
BaseParameters.Waveform?.Setup();
// Give some warnings if no value is given
if (!BaseParameters.DcValue.Given)
{
// no DC value - either have a transient value or none
CircuitWarning.Warning(this,
BaseParameters.Waveform != null
? "{0} has no DC value, transient time 0 value used".FormatString(Name)
: "{0} has no value, DC 0 assumed".FormatString(Name));
}
if (context is ComponentBindingContext cc)
{
PosNode = cc.Pins[0];
NegNode = cc.Pins[1];
}
_state = ((BaseSimulation)simulation).RealState;
var solver = _state.Solver;
PosPtr = solver.GetRhsElement(PosNode);
NegPtr = solver.GetRhsElement(NegNode);
}
/// <summary>
/// Bind the behavior.
/// </summary>
public override void Bind(Simulation simulation, BindingContext context)
{
base.Bind(simulation, context);
// Cache some objects that we will use often
_bp = context.GetParameterSet <BaseParameters>();
_state = ((BaseSimulation)simulation).RealState;
_baseConfig = simulation.Configurations.Get <BaseConfiguration>();
// Find the nodes that the resistor is connected to
if (context is ComponentBindingContext cbc)
{
_nodeA = cbc.Pins[0];
_nodeB = cbc.Pins[1];
}
// We need 4 matrix elements here
var solver = _state.Solver;
_aaPtr = solver.GetMatrixElement(_nodeA, _nodeA);
_abPtr = solver.GetMatrixElement(_nodeA, _nodeB);
_baPtr = solver.GetMatrixElement(_nodeB, _nodeA);
_bbPtr = solver.GetMatrixElement(_nodeB, _nodeB);
// We also need 2 RHS vector elements
_aPtr = solver.GetRhsElement(_nodeA);
_bPtr = solver.GetRhsElement(_nodeB);
}
/// <summary>
/// Gets matrix pointers
/// </summary>
/// <param name="variables">Nodes</param>
/// <param name="solver">Solver</param>
public override void GetEquationPointers(VariableSet variables, Solver <double> solver)
{
if (variables == null)
{
throw new ArgumentNullException(nameof(variables));
}
if (solver == null)
{
throw new ArgumentNullException(nameof(solver));
}
// Add series drain node if necessary
if (_mbp.DrainResistance > 0 || _mbp.SheetResistance > 0 && _bp.DrainSquares > 0)
{
DrainNodePrime = variables.Create(Name.Combine("drain")).Index;
}
else
{
DrainNodePrime = _drainNode;
}
// Add series source node if necessary
if (_mbp.SourceResistance > 0 || _mbp.SheetResistance > 0 && _bp.SourceSquares > 0)
{
SourceNodePrime = variables.Create(Name.Combine("source")).Index;
}
else
{
SourceNodePrime = _sourceNode;
}
// Get matrix pointers
DrainDrainPtr = solver.GetMatrixElement(_drainNode, _drainNode);
GateGatePtr = solver.GetMatrixElement(_gateNode, _gateNode);
SourceSourcePtr = solver.GetMatrixElement(_sourceNode, _sourceNode);
BulkBulkPtr = solver.GetMatrixElement(_bulkNode, _bulkNode);
DrainPrimeDrainPrimePtr = solver.GetMatrixElement(DrainNodePrime, DrainNodePrime);
SourcePrimeSourcePrimePtr = solver.GetMatrixElement(SourceNodePrime, SourceNodePrime);
DrainDrainPrimePtr = solver.GetMatrixElement(_drainNode, DrainNodePrime);
GateBulkPtr = solver.GetMatrixElement(_gateNode, _bulkNode);
GateDrainPrimePtr = solver.GetMatrixElement(_gateNode, DrainNodePrime);
GateSourcePrimePtr = solver.GetMatrixElement(_gateNode, SourceNodePrime);
SourceSourcePrimePtr = solver.GetMatrixElement(_sourceNode, SourceNodePrime);
BulkDrainPrimePtr = solver.GetMatrixElement(_bulkNode, DrainNodePrime);
BulkSourcePrimePtr = solver.GetMatrixElement(_bulkNode, SourceNodePrime);
DrainPrimeSourcePrimePtr = solver.GetMatrixElement(DrainNodePrime, SourceNodePrime);
DrainPrimeDrainPtr = solver.GetMatrixElement(DrainNodePrime, _drainNode);
BulkGatePtr = solver.GetMatrixElement(_bulkNode, _gateNode);
DrainPrimeGatePtr = solver.GetMatrixElement(DrainNodePrime, _gateNode);
SourcePrimeGatePtr = solver.GetMatrixElement(SourceNodePrime, _gateNode);
SourcePrimeSourcePtr = solver.GetMatrixElement(SourceNodePrime, _sourceNode);
DrainPrimeBulkPtr = solver.GetMatrixElement(DrainNodePrime, _bulkNode);
SourcePrimeBulkPtr = solver.GetMatrixElement(SourceNodePrime, _bulkNode);
SourcePrimeDrainPrimePtr = solver.GetMatrixElement(SourceNodePrime, DrainNodePrime);
// Get rhs pointers
BulkPtr = solver.GetRhsElement(_bulkNode);
DrainPrimePtr = solver.GetRhsElement(DrainNodePrime);
SourcePrimePtr = solver.GetRhsElement(SourceNodePrime);
}
public override PointStyle OnSelectDragPointStyle(VectorElement element, VectorElementDragPointStyle dragPointStyle)
{
if (styleNormal == null)
{
PointStyleBuilder builder = new PointStyleBuilder();
builder.Color = new Color(0, 255, 255, 255);
builder.Size = 20;
styleNormal = builder.BuildStyle();
builder.Size = 15;
styleVirtual = builder.BuildStyle();
builder.Color = new Color(255, 255, 0, 255);
builder.Size = 30;
styleSelected = builder.BuildStyle();
}
if (dragPointStyle == VectorElementDragPointStyle.VectorElementDragPointStyleSelected)
{
return(styleSelected);
}
if (dragPointStyle == VectorElementDragPointStyle.VectorElementDragPointStyleVirtual)
{
return(styleVirtual);
}
return(styleNormal);
}
/// <summary>
/// Unbind the behavior.
/// </summary>
public override void Unbind()
{
base.Unbind();
_state = null;
PosPtr = null;
NegPtr = null;
}
/// <summary>
/// Get equation pointers
/// </summary>
/// <param name="solver">Solver</param>
public void GetEquationPointers(Solver <Complex> solver)
{
if (solver == null)
{
throw new ArgumentNullException(nameof(solver));
}
CPosPtr = solver.GetRhsElement(PosNode);
CNegPtr = solver.GetRhsElement(NegNode);
}
// Converts the value of the element to a hexadecimal representation.
public static string ValueAsHex(this VectorElement element)
{
byte[] values = element.GetValues();
string hex = BitConverter
.ToString(values)
.Replace("-", "");
return($"0x{hex}");
}
/// <summary>
/// Get the matrix elements
/// </summary>
/// <param name="variables">Variables</param>
/// <param name="solver">Solver</param>
public override void GetEquationPointers(VariableSet variables, Solver <double> solver)
{
if (solver == null)
{
throw new ArgumentNullException(nameof(solver));
}
_posPtr = solver.GetRhsElement(_posNode);
_negPtr = solver.GetRhsElement(_negNode);
}
/// <summary>
/// Get equation pointers
/// </summary>
/// <param name="solver">Solver</param>
public override void GetEquationPointers(Solver <Complex> solver)
{
if (solver == null)
{
throw new ArgumentNullException(nameof(solver));
}
PosPtr = solver.GetRhsElement(_posNode);
NegPtr = solver.GetRhsElement(_negNode);
}
/// <summary>
/// Unbind the behavior.
/// </summary>
public override void Unbind()
{
base.Unbind();
_state = null;
CPosBranchPtr = null;
CBranchPosPtr = null;
CNegBranchPtr = null;
CBranchNegPtr = null;
CBranchPtr = null;
}
/// <summary>
/// Bind the behavior.
/// </summary>
/// <param name="simulation">The simulation.</param>
/// <param name="context">The context.</param>
public override void Bind(Simulation simulation, BindingContext context)
{
base.Bind(simulation, context);
var solver = ((BaseSimulation)simulation).RealState.Solver;
Ibr1Ptr = solver.GetRhsElement(BranchEq1);
Ibr2Ptr = solver.GetRhsElement(BranchEq2);
Signals = new DelayedSignal(2, BaseParameters.Delay);
}
/// <summary>
/// Gets matrix pointers
/// </summary>
/// <param name="variables">Nodes</param>
/// <param name="solver">Solver</param>
public void GetEquationPointers(VariableSet variables, Solver <double> solver)
{
variables.ThrowIfNull(nameof(variables));
solver.ThrowIfNull(nameof(solver));
// Add series drain node if necessary
if (ModelParameters.DrainResistance > 0 || ModelParameters.SheetResistance > 0 && BaseParameters.DrainSquares > 0)
{
DrainNodePrime = variables.Create(Name.Combine("drain")).Index;
}
else
{
DrainNodePrime = DrainNode;
}
// Add series source node if necessary
if (ModelParameters.SourceResistance > 0 || ModelParameters.SheetResistance > 0 && BaseParameters.SourceSquares > 0)
{
SourceNodePrime = variables.Create(Name.Combine("source")).Index;
}
else
{
SourceNodePrime = SourceNode;
}
// Get matrix pointers
DrainDrainPtr = solver.GetMatrixElement(DrainNode, DrainNode);
GateGatePtr = solver.GetMatrixElement(GateNode, GateNode);
SourceSourcePtr = solver.GetMatrixElement(SourceNode, SourceNode);
BulkBulkPtr = solver.GetMatrixElement(BulkNode, BulkNode);
DrainPrimeDrainPrimePtr = solver.GetMatrixElement(DrainNodePrime, DrainNodePrime);
SourcePrimeSourcePrimePtr = solver.GetMatrixElement(SourceNodePrime, SourceNodePrime);
DrainDrainPrimePtr = solver.GetMatrixElement(DrainNode, DrainNodePrime);
GateBulkPtr = solver.GetMatrixElement(GateNode, BulkNode);
GateDrainPrimePtr = solver.GetMatrixElement(GateNode, DrainNodePrime);
GateSourcePrimePtr = solver.GetMatrixElement(GateNode, SourceNodePrime);
SourceSourcePrimePtr = solver.GetMatrixElement(SourceNode, SourceNodePrime);
BulkDrainPrimePtr = solver.GetMatrixElement(BulkNode, DrainNodePrime);
BulkSourcePrimePtr = solver.GetMatrixElement(BulkNode, SourceNodePrime);
DrainPrimeSourcePrimePtr = solver.GetMatrixElement(DrainNodePrime, SourceNodePrime);
DrainPrimeDrainPtr = solver.GetMatrixElement(DrainNodePrime, DrainNode);
BulkGatePtr = solver.GetMatrixElement(BulkNode, GateNode);
DrainPrimeGatePtr = solver.GetMatrixElement(DrainNodePrime, GateNode);
SourcePrimeGatePtr = solver.GetMatrixElement(SourceNodePrime, GateNode);
SourcePrimeSourcePtr = solver.GetMatrixElement(SourceNodePrime, SourceNode);
DrainPrimeBulkPtr = solver.GetMatrixElement(DrainNodePrime, BulkNode);
SourcePrimeBulkPtr = solver.GetMatrixElement(SourceNodePrime, BulkNode);
SourcePrimeDrainPrimePtr = solver.GetMatrixElement(SourceNodePrime, DrainNodePrime);
// Get rhs pointers
BulkPtr = solver.GetRhsElement(BulkNode);
DrainPrimePtr = solver.GetRhsElement(DrainNodePrime);
SourcePrimePtr = solver.GetRhsElement(SourceNodePrime);
}
// Allocate Y-matrix and RHS-vector elements
public override void GetEquationPointers(VariableSet variables, Solver <double> solver)
{
// We need 4 matrix elements here
_aaPtr = solver.GetMatrixElement(_nodeA, _nodeA);
_abPtr = solver.GetMatrixElement(_nodeA, _nodeB);
_baPtr = solver.GetMatrixElement(_nodeB, _nodeA);
_bbPtr = solver.GetMatrixElement(_nodeB, _nodeB);
// We also need 2 RHS vector elements
_aPtr = solver.GetRhsElement(_nodeA);
_bPtr = solver.GetRhsElement(_nodeB);
}
public static float GetElement(this Vector2 v, VectorElement element)
{
switch (element)
{
case VectorElement.X:
return v.X;
case VectorElement.Y:
return v.Y;
default:
throw new Exception("Tried to get non-existent element from vector.");
}
}
public static Vector2 SetElement(this Vector2 v, VectorElement element, float value)
{
switch (element)
{
case VectorElement.X:
return new Vector2(value, v.Y);
case VectorElement.Y:
return new Vector2(v.X, value);
default:
throw new Exception("Tried to set non-existent element in vector.");
}
}
/// <summary>
/// Gets the original data values by expanding
/// sequences and applying scale and offset.
/// </summary>
/// <returns>A list of the original data values.</returns>
private IList <object> GetOriginalValues()
{
IList <object> values = new List <object>();
VectorElement valuesVector = SeriesValues;
StorageMethods storageMethods = Definition.StorageMethodID;
bool incremented = (storageMethods & StorageMethods.Increment) != 0;
dynamic start, count, increment;
bool scaled = (storageMethods & StorageMethods.Scaled) != 0;
dynamic offset = ((object)SeriesOffset != null) ? SeriesOffset.Get() : 0;
dynamic scale = ((object)SeriesScale != null) ? SeriesScale.Get() : 1;
dynamic value;
if (!scaled)
{
offset = 0;
scale = 1;
}
if (incremented)
{
start = valuesVector.Get(0);
count = valuesVector.Get(1);
increment = valuesVector.Get(2);
for (int i = 0; i < count; i++)
{
values.Add((object)(start + (i * increment)));
}
}
else
{
for (int i = 0; i < valuesVector.Size; i++)
{
values.Add(valuesVector.Get(i));
}
}
if (valuesVector.TypeOfValue != PhysicalType.Timestamp)
{
for (int i = 0; i < values.Count; i++)
{
value = values[i];
values[i] = offset + (value * scale);
}
ApplyTransducerRatio(values);
}
return(values);
}
/// <summary>
/// Add element in vector from array.
/// </summary>
/// <param name="value">element`s value</param>
private void AddElementInVector(int value)
{
if (head == null)
{
head = new VectorElement(value, null);
tail = head;
return;
}
var currentElement = new VectorElement(value, null);
tail.next = currentElement;
tail = currentElement;
}
/// <summary>
/// Gets matrix pointers
/// </summary>
/// <param name="solver">Solver</param>
public void GetEquationPointers(Solver <Complex> solver)
{
solver.ThrowIfNull(nameof(solver));
// Get matrix elements
CPosBranchPtr = solver.GetMatrixElement(PosNode, BranchEq);
CBranchPosPtr = solver.GetMatrixElement(BranchEq, PosNode);
CNegBranchPtr = solver.GetMatrixElement(NegNode, BranchEq);
CBranchNegPtr = solver.GetMatrixElement(BranchEq, NegNode);
// Get rhs elements
CBranchPtr = solver.GetRhsElement(BranchEq);
}
/// <summary>
/// Unbind the behavior.
/// </summary>
public override void Unbind()
{
base.Unbind();
_bp = null;
_state = null;
_baseConfig = null;
_aaPtr = null;
_abPtr = null;
_baPtr = null;
_bbPtr = null;
_aPtr = null;
_bPtr = null;
}
/// <summary>
/// Bind behavior.
/// </summary>
/// <param name="simulation">The simulation.</param>
/// <param name="context">Data provider</param>
public override void Bind(Simulation simulation, BindingContext context)
{
base.Bind(simulation, context);
// Get parameters
FrequencyParameters = context.GetParameterSet <CommonBehaviors.IndependentSourceFrequencyParameters>();
_state = ((FrequencySimulation)simulation).ComplexState;
var solver = _state.Solver;
CPosPtr = solver.GetRhsElement(PosNode);
CNegPtr = solver.GetRhsElement(NegNode);
}
/// <summary>
/// Gets matrix pointer
/// </summary>
/// <param name="solver">Matrix</param>
public void GetEquationPointers(Solver <double> solver)
{
if (solver == null)
{
throw new ArgumentNullException(nameof(solver));
}
// Get vector elements
BranchPtr = solver.GetRhsElement(BranchEq);
// Get matrix elements
BranchBranchPtr = solver.GetMatrixElement(BranchEq, BranchEq);
}
/// <summary>
/// Gets matrix pointer
/// </summary>
/// <param name="solver">Matrix</param>
public override void GetEquationPointers(Solver <double> solver)
{
if (solver == null)
{
throw new ArgumentNullException(nameof(solver));
}
// Get current equation
_branchEq = _load.BranchEq;
BranchPtr = solver.GetRhsElement(_branchEq);
// Get matrix pointers
BranchBranchPtr = solver.GetMatrixElement(_branchEq, _branchEq);
}
public static Vector2 SetElement(this Vector2 v, VectorElement element, float value)
{
switch (element)
{
case VectorElement.X:
return(new Vector2(value, v.Y));
case VectorElement.Y:
return(new Vector2(v.X, value));
default:
throw new Exception("Tried to set non-existent element in vector.");
}
}
public static float GetElement(this Vector2 v, VectorElement element)
{
switch (element)
{
case VectorElement.X:
return(v.X);
case VectorElement.Y:
return(v.Y);
default:
throw new Exception("Tried to get non-existent element from vector.");
}
}
private double CalculateValueTotalWeight(Vector <double> vector, double value)
{
double sum = 0;
for (int i = 0; i < vector.Length; ++i)
{
VectorElement element = vector[i];
if (element.Value == value)
{
sum += (1 / (element.Value * element.Weight));
}
}
return(sum);
}
// Converts the value of the element to a string representation.
public static string ValueAsString(this VectorElement element)
{
// The physical types Char1 and Char2 indicate the value is a string
if (element.TypeOfValue == PhysicalType.Char1)
{
return(Encoding.ASCII.GetString(element.GetValues()).Trim((char)0));
}
if (element.TypeOfValue == PhysicalType.Char2)
{
return(Encoding.Unicode.GetString(element.GetValues()).Trim((char)0));
}
// Get the tag definition of the element being displayed
Tag?tag = Tag.GetTag(element.TagOfElement);
// Determine the format in which to display the values
// based on the tag definition and the type of the value
Func <int, string> formatter = element.TypeOfValue switch
{
PhysicalType.Complex8 => index => ((Complex)element.Get(index)).ToComplexNotation(),
PhysicalType.Complex16 => index => ((Complex)element.Get(index)).ToComplexNotation(),
PhysicalType.Timestamp => index =>
{
string format = tag?.FormatString ?? "{0:yyyy-MM-dd HH:mm:ss.fffffff}";
object value = element.Get(index);
return(string.Format(format, value));
},
_ => index =>
{
string format = tag?.FormatString ?? "{0}";
object value = element.Get(index);
return(string.Format(format, value));
}
};
// Convert the values to their string representations
IEnumerable <string> values = Enumerable
.Range(0, element.Size)
.Select(formatter);
// Join the values in the collection
// to a single, comma-separated string
string join = string.Join(", ", values);
// Wrap the string in curly braces and return
return($"{{ {join} }}");
}
public override void OnElementModify(VectorElement element, Geometry geometry)
{
if (element is Point && geometry is PointGeometry)
{
(element as Point).Geometry = (PointGeometry)geometry;
}
else if (element is Line && geometry is LineGeometry)
{
(element as Line).Geometry = (LineGeometry)geometry;
}
else if (element is Polygon && geometry is PolygonGeometry)
{
(element as Polygon).Geometry = (PolygonGeometry)geometry;
}
}
/// <summary>
/// Sets the values to be written to the PQDIF
/// file for the increment storage method.
/// </summary>
/// <param name="start">The start of the increment.</param>
/// <param name="count">The number of values in the series.</param>
/// <param name="increment">The amount by which to increment each value in the series.</param>
public void SetValues(object start, object count, object increment)
{
VectorElement seriesValuesElement;
seriesValuesElement = new VectorElement()
{
Size = 3,
TagOfElement = SeriesValuesTag,
TypeOfValue = PhysicalTypeExtensions.GetPhysicalType(start.GetType())
};
seriesValuesElement.Set(0, start);
seriesValuesElement.Set(1, count);
seriesValuesElement.Set(2, increment);
}
private static DateTime[] ParseTimeData(SeriesInstance seriesInstance, double systemFrequency)
{
DateTime[] timeData;
SeriesDefinition timeSeriesDefinition = seriesInstance.Definition;
if (timeSeriesDefinition.ValueTypeID != SeriesValueType.Time)
{
return(null);
}
VectorElement seriesValues = seriesInstance.SeriesValues;
if (seriesValues.TypeOfValue == PhysicalType.Timestamp)
{
timeData = seriesInstance.OriginalValues
.Select(Convert.ToDateTime)
.ToArray();
}
else if (timeSeriesDefinition.QuantityUnits == QuantityUnits.Cycles)
{
ChannelInstance channelInstance = seriesInstance.Channel;
DateTime startTime = channelInstance.ObservationRecord.StartTime;
double nominalFrequency = channelInstance.ObservationRecord?.Settings.NominalFrequency ?? systemFrequency;
timeData = seriesInstance.OriginalValues
.Select(Convert.ToDouble)
.Select(cycles => cycles / nominalFrequency)
.Select(seconds => (long)(seconds * TimeSpan.TicksPerSecond))
.Select(TimeSpan.FromTicks)
.Select(timeSpan => startTime + timeSpan)
.ToArray();
}
else
{
ChannelInstance channelInstance = seriesInstance.Channel;
DateTime startTime = channelInstance.ObservationRecord.StartTime;
timeData = seriesInstance.OriginalValues
.Select(Convert.ToDouble)
.Select(seconds => (long)(seconds * TimeSpan.TicksPerSecond))
.Select(TimeSpan.FromTicks)
.Select(timeSpan => startTime + timeSpan)
.ToArray();
}
return(timeData);
}
/// <summary>
/// Gets matrix pointers
/// </summary>
/// <param name="variables">Variables</param>
/// <param name="solver">Solver</param>
public void GetEquationPointers(VariableSet variables, Solver <double> solver)
{
variables.ThrowIfNull(nameof(variables));
solver.ThrowIfNull(nameof(solver));
BranchEq = variables.Create(Name.Combine("branch"), VariableType.Current).Index;
// Get matrix elements
PosBranchPtr = solver.GetMatrixElement(PosNode, BranchEq);
BranchPosPtr = solver.GetMatrixElement(BranchEq, PosNode);
NegBranchPtr = solver.GetMatrixElement(NegNode, BranchEq);
BranchNegPtr = solver.GetMatrixElement(BranchEq, NegNode);
// Get rhs elements
BranchPtr = solver.GetRhsElement(BranchEq);
}
/// <summary>
/// Gets matrix pointers
/// </summary>
/// <param name="solver">Solver</param>
public override void GetEquationPointers(Solver <Complex> solver)
{
if (solver == null)
{
throw new ArgumentNullException(nameof(solver));
}
// Get matrix elements
PosBranchPtr = solver.GetMatrixElement(_posNode, _branchEq);
BranchPosPtr = solver.GetMatrixElement(_branchEq, _posNode);
NegBranchPtr = solver.GetMatrixElement(_negNode, _branchEq);
BranchNegPtr = solver.GetMatrixElement(_branchEq, _negNode);
// Get rhs elements
BranchPtr = solver.GetRhsElement(_branchEq);
}
private UIComponent buildValueMemberField(Type type, IProperty property, VectorElement element)
{
Container field = new Container();
field.Tint.Value = Color.Black;
field.Add(new Binding<float, bool>(field.Opacity, x => x ? 1.0f : 0.5f, field.Highlighted));
TextElement textField = new TextElement();
textField.FontFile.Value = "Font";
field.Children.Add(textField);
field.Add(new CommandBinding<Point>(field.MouseLeftDown, delegate(Point mouse)
{
field.SwallowMouseEvents.Value = true;
field.MouseLocked.Value = true;
}));
field.Add(new CommandBinding<Point>(field.MouseLeftUp, delegate(Point mouse)
{
field.SwallowMouseEvents.Value = false;
field.MouseLocked.Value = false;
}));
if (type.Equals(typeof(Vector2)))
{
Property<Vector2> socket = (Property<Vector2>)property;
field.Add(new CommandBinding<Point, int>(field.MouseScrolled, () => this.selectedStringProperty == null && field.MouseLocked, delegate(Point mouse, int scroll)
{
this.NeedsSave.Value = true;
float delta = scroll * (this.EnablePrecision ? EditorUI.precisionDelta : EditorUI.normalDelta);
socket.Value = socket.Value.SetElement(element, socket.Value.GetElement(element) + delta);
}));
textField.Add(new Binding<string, Vector2>(textField.Text, x => x.GetElement(element).ToString("F"), socket));
}
else if (type.Equals(typeof(Vector3)))
{
Property<Vector3> socket = (Property<Vector3>)property;
field.Add(new CommandBinding<Point, int>(field.MouseScrolled, () => this.selectedStringProperty == null && field.MouseLocked, delegate(Point mouse, int scroll)
{
this.NeedsSave.Value = true;
float delta = scroll * (this.EnablePrecision ? EditorUI.precisionDelta : EditorUI.normalDelta);
socket.Value = socket.Value.SetElement(element, socket.Value.GetElement(element) + delta);
}));
textField.Add(new Binding<string, Vector3>(textField.Text, x => x.GetElement(element).ToString("F"), socket));
}
else if (type.Equals(typeof(Vector4)))
{
Property<Vector4> socket = (Property<Vector4>)property;
field.Add(new CommandBinding<Point, int>(field.MouseScrolled, () => this.selectedStringProperty == null && field.MouseLocked, delegate(Point mouse, int scroll)
{
this.NeedsSave.Value = true;
float delta = scroll * (this.EnablePrecision ? EditorUI.precisionDelta : EditorUI.normalDelta);
socket.Value = socket.Value.SetElement(element, socket.Value.GetElement(element) + delta);
}));
textField.Add(new Binding<string, Vector4>(textField.Text, x => x.GetElement(element).ToString("F"), socket));
}
else if (type.Equals(typeof(Quaternion)))
{
Property<Quaternion> socket = (Property<Quaternion>)property;
field.Add(new CommandBinding<Point, int>(field.MouseScrolled, () => this.selectedStringProperty == null && field.MouseLocked, delegate(Point mouse, int scroll)
{
this.NeedsSave.Value = true;
float delta = scroll * (this.EnablePrecision ? EditorUI.precisionDelta : EditorUI.normalDelta);
socket.Value = socket.Value.SetElement(element, socket.Value.GetElement(element) + delta);
}));
textField.Add(new Binding<string, Quaternion>(textField.Text, x => x.GetElement(element).ToString("F"), socket));
}
else if (type.Equals(typeof(Color)))
{
Property<Color> socket = (Property<Color>)property;
field.Add(new CommandBinding<Point, int>(field.MouseScrolled, () => this.selectedStringProperty == null && field.MouseLocked, delegate(Point mouse, int scroll)
{
this.NeedsSave.Value = true;
socket.Value = socket.Value.SetElement(element, (byte)Math.Max(0, Math.Min(255, socket.Value.GetElement(element) + scroll)));
}));
textField.Add(new Binding<string, Color>(textField.Text, x => x.GetElement(element).ToString(), socket));
}
return field;
}
public static byte GetElement(this Color v, VectorElement element)
{
switch (element)
{
case VectorElement.X:
return v.R;
case VectorElement.Y:
return v.G;
case VectorElement.Z:
return v.B;
case VectorElement.W:
return v.A;
default:
throw new Exception("Tried to get non-existent element from color.");
}
}
public override void OnVectorElementClicked(VectorElement element, double x, double y, bool longClick)
{
Log.Debug ("NT", "OnVectorElementClicked " + x + " " + y + " " + element+ " " + longClick);
}
public static Color SetElement(this Color v, VectorElement element, byte value)
{
switch (element)
{
case VectorElement.X:
return new Color(value, v.G, v.B, v.A);
case VectorElement.Y:
return new Color(v.R, value, v.B, v.A);
case VectorElement.Z:
return new Color(v.R, v.G, value, v.A);
case VectorElement.W:
return new Color(v.R, v.G, v.B, value);
default:
throw new Exception("Tried to set non-existent element in color.");
}
}
public override void OnLabelClicked(VectorElement element, bool longClick)
{
Log.Debug ("NT", "OnLabelClicked " + element+ " " + longClick);
}
public abstract void VisitVectorSingleElement(VectorElement element);
public override void VisitVectorSingleElement(VectorElement element)
{
//throw new NotImplementedException();
}
public override void VisitVectorSingleElement(VectorElement element)
{
try
{
VectorElement temp = element;
if (inParallelFor == 1)
{
if (parallelVars.Contains(element.getVar().getText()))
{
}
else
{
vectorData(element.getVar().getText());
}
parallelString.Append(temp.getVar().getText());
parallelString.Append("[");
if (temp.getRange() is VariableElement)
parallelString.Append(((VariableElement)temp.getRange()).getText());
else if (temp.getRange() is IntegerElement)
parallelString.Append(((IntegerElement)temp.getRange()).getText());
parallelString.Append("]");
}
else
{
PerformVectorSingleElementOperation(element);
}
}
catch (Exception e) { sendres(112, "Error in vector element\n"); e.GetType(); }
}
public static Quaternion SetElement(this Quaternion v, VectorElement element, float value)
{
switch (element)
{
case VectorElement.X:
return new Quaternion(value, v.Y, v.Z, v.W);
case VectorElement.Y:
return new Quaternion(v.X, value, v.Z, v.W);
case VectorElement.Z:
return new Quaternion(v.X, v.Y, value, v.W);
case VectorElement.W:
return new Quaternion(v.X, v.Y, v.Z, value);
default:
throw new Exception("Tried to set non-existent element in vector.");
}
}
public void PerformVectorSingleElementOperation(VectorElement temp)
{
if (map_contains_matrix(temp.getVar().getText()))
{
VectorVariableDeclaration matTemp = null;
if (temp != null)
{
matTemp = (VectorVariableDeclaration)mVariableMap[temp.getVar().getText()];
int loc = getIndex(temp);
if (matTemp != null)
{
if (loc < int.Parse(matTemp.getRange().getText()))
{
if (matTemp.getType() == "int")
{
int val = matTemp.getintValueat(loc);
IntegerElement elem = new IntegerElement();
elem.setText(val.ToString());
mat_stack.Push(elem);
}
else if (matTemp.getType() == "double")
{
double val = matTemp.getdoubleValueat(loc);
DoubleElement elem = new DoubleElement();
elem.setText(val.ToString());
mat_stack.Push(elem);
}
}
else
{
Console.Write("Range out of bound\n");
sendres(112, "Range out of bound\n");
}
}
}
}
}
private int getIndex(VectorElement temp)
{
try
{
if (temp.getRange() is IntegerElement)
{
string r = ((IntegerElement)temp.getRange()).getText();
return int.Parse(r);
}
else
{
string r = ((IntegerElement)(mVariableMap[((VariableElement)temp.getRange()).getText()])).getText();
return int.Parse(r);
}
}
catch (Exception e) { sendres(112, "Invalid index\n"); e.GetType(); return 0; }
}