using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Serialization;
using CategoryTheory;
using DiagramUI;
using BaseTypes;
using DataPerformer.Interfaces;
using DataPerformer;
namespace AggregateLibrary
{
[Serializable()]
class ForcedRigidBody : RigidBody, IDataConsumer, IPostSetArrow
{
#region Fields
private string forceVector = "";
private string momentumVector = "";
private IMeasure force;
private IMeasure momentum;
private List<IMeasurements> measurements = new List<IMeasurements>();
Action update = delegate()
{
};
#endregion
#region Ctor
internal ForcedRigidBody()
: base(false)
{
}
protected ForcedRigidBody(SerializationInfo info, StreamingContext context)
: base(info, context)
{
}
#endregion
#region Overriden
public override object Properties
{
get
{
object[] o = new object[] { momemtOfInertia, connections, aliasNames, inerialAccelerationStr, forcesStr, mass, initialState,
forceVector, momentumVector};
return LibraryObjectWrapper.TransformToBytes(o);
}
set
{
base.Properties = value;
}
}
public override object Editor
{
get
{
return new object[] { Form, ResourceImage.RigidBodyVector };
}
}
protected override void SetProperties(object[] o)
{
base.SetProperties(o);
forceVector = o[7] + "";
momentumVector = o[8] + "";
}
#endregion
#region IDataConsumer Members
void IDataConsumer.Add(IMeasurements measurements)
{
this.measurements.Add(measurements);
}
void IDataConsumer.Remove(IMeasurements measurements)
{
this.measurements.Remove(measurements);
}
void IDataConsumer.UpdateChildrenData()
{
StaticDataPerformer.UpdateChildrenData(measurements);
}
int IDataConsumer.Count
{
get { return measurements.Count; }
}
IMeasurements IDataConsumer.this[int number]
{
get { return measurements[number]; }
}
void IDataConsumer.Reset()
{
this.FullReset();
}
#endregion
#region IPostSetArrow Members
void IPostSetArrow.PostSetArrow()
{
Set();
}
#endregion
#region Members
internal List<string> ExternalMeasurements
{
get
{
List<string> l = new List<string>();
Dictionary<string,object> d = this.GetAllMeasuresType();
foreach (string measure in d.Keys)
{
object o = d[measure];
if (!(o is ArrayReturnType))
{
continue;
}
ArrayReturnType art = o as ArrayReturnType;
int[] dim = art.Dimension;
if (dim.Length != 1)
{
continue;
}
if (dim[0] == 3)
{
l.Add(measure);
}
}
return l;
}
}
internal void Set(string force, string momentum)
{
forceVector = force;
momentumVector = momentum;
Set();
}
internal string[] Vectors
{
get
{
return new string[] { forceVector, momentumVector };
}
}
private void Set()
{
if (forceVector.Length > 0)
{
IMeasure m = this.FindMeasure(forceVector, false);
bool b = IsObject(m);
if (b)
{
AddForce = delegate()
{
AddObject(internalAcceleration, m, 0);
};
}
else
{
AddForce = delegate()
{
AddDouble(internalAcceleration, m, 0);
};
}
}
else
{
AddForce = delegate()
{
};
}
if (momentumVector.Length > 0)
{
IMeasure m = this.FindMeasure(momentumVector, false);
bool b = IsObject(m);
if (b)
{
AddMomentum = delegate()
{
AddObject(v3d, m, 0);
};
}
else
{
AddMomentum = delegate()
{
AddDouble(v3d, m, 0);
};
}
}
else
{
AddMomentum = delegate()
{
};
}
}
void AddDouble(double[] x, object o, int offset)
{
double[] d = o as double[];
for (int i = 0; i < d.Length; i++)
{
x[i + offset] += d[i];
}
}
void AddObject(double[] x, object o, int offset)
{
object[] ob = o as object[];
for (int i = 0; i < 3; i++)
{
x[i + offset] += (double)ob[i];
}
}
void AddDouble(double[] x, IMeasure m, int offset)
{
AddDouble(x, m.Parameter(), offset);
}
void AddObject(double[] x, IMeasure m, int offset)
{
AddObject(x, m.Parameter(), offset);
}
bool IsObject(IMeasure m)
{
ArrayReturnType art = m.Type as ArrayReturnType;
return art.IsObjectType;
}
#endregion
}
}
Submit an article or tip