public void IndexAccessorTest(string points, int index, string expected)
{
var testElement = new PolyLine2D(from x in points.Split(';') select Point2D.Parse(x));
var checkElement = Point2D.Parse(expected);
AssertGeometry.AreEqual(checkElement, testElement.Vertices.Skip(index).First());
}
public Polygon2D GetPolygon()
{
var point1 = new Point2D(0, 0);
var point2 = new Point2D(0, Depth);
var point3 = new Point2D(Width, Depth);
var point4 = new Point2D(Width, 0);
var point5 = point1;
var pointList = new List <Point2D>()
{
point1,
point2,
point3,
point4,
point5
};
var polyLine2D = new PolyLine2D(pointList);
var moveLine = new Line2D(point1, Location);
var moveVector = moveLine.Direction * moveLine.Length;
var polygon = new Polygon2D(pointList);
polygon = polygon.RotateAround(Rotation, point1);
polygon = polygon.TranslateBy(moveVector);
return(polygon);
}
public static IPolyLine2D Convert(this Polyline source)
{
var target = new PolyLine2D(source.Segments.Count);
foreach (var s in source.Segments)
{
ISegment2D segment = null;
switch (s.Type)
{
case SegmentType.StartPoint:
target.StartPoint = new Point(s.Parameters[0], s.Parameters[1]);
continue;
case SegmentType.Line:
segment = new LineSegment2D(new Point(s.Parameters[0], s.Parameters[1]));
break;
case SegmentType.CircArc3Points:
segment = new CircularArcSegment2D(new Point(s.Parameters[0], s.Parameters[1]), new Point(s.Parameters[2], s.Parameters[3]));
break;
}
target.Segments.Add(segment);
}
return(target);
}
public void IndexAccessorTest(string points, int index, string expected)
{
var testElement = new PolyLine2D(from x in points.Split(';') select Point2D.Parse(x));
var checkElement = Point2D.Parse(expected);
Assert.AreEqual(checkElement, testElement[index]);
}
public void GetPointAtFractionAlongCurveThrowsArgumentException(string points, double fraction, string expected)
{
var testElement = new PolyLine2D(from x in points.Split(';') select Point2D.Parse(x));
var checkElement = Point2D.Parse(expected);
Assert.Throws <ArgumentException>(() => { testElement.GetPointAtFractionAlongCurve(fraction); });
}
public void GetPointAtFractionAlongCurveThrowsArgumentException(string points, double fraction, string expected)
{
var testElement = new PolyLine2D(from x in points.Split(';') select Point2D.Parse(x));
var checkElement = Point2D.Parse(expected);
Assert.Throws<ArgumentException>(() => { testElement.GetPointAtFractionAlongCurve(fraction); });
}
private void InitializeCrack()
{
var globalHomogeneousMaterial = HomogeneousElasticMaterial2D.CreateMaterialForPlaneStrain(E, v);
IPropagator propagator = new Propagator(mesh, jIntegralRadiusOverElementSize,
new HomogeneousMaterialAuxiliaryStates(globalHomogeneousMaterial),
new HomogeneousSIFCalculator(globalHomogeneousMaterial),
new MaximumCircumferentialTensileStressCriterion(), new ConstantIncrement2D(growthLength));
CrackMouth = new CartesianPoint(0.0, h / 2);
var crackKink = new CartesianPoint(a, h / 2);
var initialCrack = new PolyLine2D(CrackMouth, crackKink);
initialCrack.UpdateGeometry(-dTheta, da);
//var crackTip = new CartesianPoint(a + da * Math.Cos(dTheta), h/2 - da * Math.Sin(dTheta));
var lsmCrack = new TrackingExteriorCrackLSM(propagator, tipEnrichmentRadius, new RelativeAreaResolver(heavisideTol));
lsmCrack.Mesh = mesh;
// Create enrichments
lsmCrack.CrackBodyEnrichment = new CrackBodyEnrichment2D(lsmCrack);
lsmCrack.CrackTipEnrichments = new CrackTipEnrichments2D(lsmCrack, CrackTipPosition.Single);
if (lsmPlotDirectory != null)
{
lsmCrack.EnrichmentLogger = new EnrichmentLogger(Model, lsmCrack, lsmPlotDirectory);
lsmCrack.LevelSetLogger = new LevelSetLogger(Model, lsmCrack, lsmPlotDirectory);
lsmCrack.LevelSetComparer = new PreviousLevelSetComparer(lsmCrack, lsmPlotDirectory);
}
// Mesh geometry interaction
lsmCrack.InitializeGeometry(initialCrack);
//lsmCrack.UpdateGeometry(-dTheta, da);
this.crack = lsmCrack;
}
public void IndexAccessorTest(string points, int index, string expected)
{
var testElement = new PolyLine2D(from x in points.Split(';') select Point2D.Parse(x));
var checkElement = Point2D.Parse(expected);
Assert.AreEqual(checkElement, testElement[index]);
}
//TODO: This should work for any IOpenCurve2D. Same for all ICrackGeometryDescriptions.
//TODO: The tangent stuff should be done by the initial curve.
public void InitializeGeometry(PolyLine2D initialCrack)
{
foreach (var vertex in initialCrack.Vertices)
{
crackPath.Add(vertex);
}
crackMouth = initialCrack.Start;
var lastSegment = initialCrack.Segments[initialCrack.Segments.Count - 1];
double tangentX = lastSegment.End.X - lastSegment.Start.X;
double tangentY = lastSegment.End.Y - lastSegment.Start.Y;
double length = Math.Sqrt(tangentX * tangentX + tangentY * tangentY);
double tangentSlope = Math.Atan2(tangentY, tangentX);
this.crackTip = initialCrack.End;
tipSystem = new TipCoordinateSystem(crackTip, tangentSlope);
CrackTipEnrichments.TipSystem = tipSystem;
tangentX /= length;
tangentY /= length;
foreach (XNode node in Mesh.Nodes)
{
levelSetsBody[node] = initialCrack.SignedDistanceOf(node);
levelSetsTip[node] = (node.X - crackTip.X) * tangentX + (node.Y - crackTip.Y) * tangentY;
}
if (LevelSetLogger != null)
{
LevelSetLogger.InitialLog(); //TODO: handle this with a NullLogger.
}
}
[TestCase("0,0;0,1;1,1", "0.5,1.5", "0.5,1")] // Off curve
public void ClosestPointToTest(string points, string testPoint, string expectedPoint)
{
var testCurve = new PolyLine2D(from x in points.Split(';') select Point2D.Parse(x));
var test = Point2D.Parse(testPoint);
var expected = Point2D.Parse(expectedPoint);
Assert.AreEqual(expected, testCurve.ClosestPointTo(test));
}
public void ClosestPointToTest(string points, string testPoint, string expectedPoint)
{
var testCurve = new PolyLine2D(from x in points.Split(';') select Point2D.Parse(x));
var test = Point2D.Parse(testPoint);
var expected = Point2D.Parse(expectedPoint);
Assert.AreEqual(expected, testCurve.ClosestPointTo(test));
}
public void GetPointAtFractionAlongCurve(string points, double fraction, string expected)
{
// Note that this method also tests GetPointAtLengthFromStart(...)
var testElement = new PolyLine2D(from x in points.Split(';') select Point2D.Parse(x));
var checkElement = Point2D.Parse(expected);
Assert.AreEqual(checkElement, testElement.GetPointAtFractionAlongCurve(fraction));
}
public void PolyLine2DBinaryFormatter()
{
var points = from x in new string[] { "0.25,0", "0.5,1", "1,-1" } select Point2D.Parse(x);
var p = new PolyLine2D(points);
var result = this.BinaryFormmaterRoundTrip(p);
Assert.AreEqual(p, result);
}
private bool draw; //描画フラグ
#region VirtualFunction
public override void Initialize(UnitEditor unitEditor)
{
base.Initialize(unitEditor);
mainLine = new PolyLine2D();
subLine = new PolyLine2D();
mf = GetComponent <MeshFilter>();
eMeshes = new EasyMesh[2];
}
public void GetPointAtFractionAlongCurve(string points, double fraction, string expected)
{
// Note that this method also tests GetPointAtLengthFromStart(...)
var testElement = new PolyLine2D(from x in points.Split(';') select Point2D.Parse(x));
var checkElement = Point2D.Parse(expected);
Assert.AreEqual(checkElement, testElement.GetPointAtFractionAlongCurve(fraction));
}
public void PolyLine2DProtoBuf()
{
var points = from x in new string[] { "0.25,0", "0.5,1", "1,-1" } select Point2D.Parse(x);
var p = new PolyLine2D(points);
var result = this.ProtobufRoundTrip(p);
Assert.AreEqual(p, result);
}
public void PolyLine2DDataContract()
{
var points = from x in new string[] { "0.25,0", "0.5,1", "1,-1" } select Point2D.Parse(x);
var p = new PolyLine2D(points);
const string ElementXml = @"<PolyLine2D><Points><Point2D><X>0.25</X><Y>0</Y></Point2D><Point2D><X>0.5</X><Y>1</Y></Point2D><Point2D><X>1</X><Y>-1</Y></Point2D></Points></PolyLine2D>";
var result = this.DataContractRoundTrip(p, ElementXml);
Assert.AreEqual(p, result);
}
public void PolyLine2DXml()
{
var points = from x in new string[] { "0.25,0", "0.5,1", "1,-1" } select Point2D.Parse(x);
var p = new PolyLine2D(points);
const string Xml = @"<PolyLine2D><Points><Point X=""0.25"" Y=""0"" /><Point X=""0.5"" Y=""1"" /><Point X=""1"" Y=""-1"" /></Points></PolyLine2D>";
var result = AssertXml.XmlSerializerRoundTrip(p, Xml);
Assert.AreEqual(p, result);
}
internal static IPolyLine2D ToPolyline2D(Rect rect)
{
var p = new PolyLine2D
{
StartPoint = rect.BottomLeft,
};
p.Segments.Add(new LineSegment2D(rect.BottomRight));
p.Segments.Add(new LineSegment2D(rect.TopRight));
p.Segments.Add(new LineSegment2D(rect.TopLeft));
p.Segments.Add(new LineSegment2D(rect.BottomLeft));
return(p);
}
public static bool LiesOnPolyline(this Point2D point, PolyLine2D line, double Tolerance = 0.0001)
{
List <Point2D> Vertices = line.Vertices.ToList();
for (int i = 0; i < Vertices.Count - 1; i++)
{
Point2D v0 = Vertices[i];
Point2D v1 = Vertices[i + 1];
double MaxX = Math.Max(v0.X, v1.X);
double MinX = Math.Min(v0.X, v1.X);
double MaxY = Math.Max(v0.Y, v1.Y);
double MinY = Math.Min(v0.Y, v1.Y);
if (v0.X == v1.X)
{
if (Math.Abs(point.X - v0.X) <= Tolerance)
{
if (point.Y >= MinY - Tolerance && point.Y <= MaxY + Tolerance)
{
return(true);
}
}
}
else
{
double m = (v1.Y - v0.Y) / (v1.X - v0.X);
double b = v0.Y - m * v0.X;
if (point.X >= MinX - Tolerance && point.X <= MaxX + Tolerance)
{
if (Math.Abs(point.Y - (m * point.X + b)) <= Tolerance)
{
return(true);
}
}
}
}
return(false);
}
private static XContinuumElement2D CreateMaterialInterfaceElement()
{
XNode[] nodes = new XNode[]
{
new XNode(0, 20.0, 0.0),
new XNode(1, 40.0, 0.0),
new XNode(2, 40.0, 20.0),
new XNode(3, 20.0, 20.0),
};
var point1 = new CartesianPoint(30.0, 0.0);
var point2 = new CartesianPoint(30.0, 20.0);
PolyLine2D discontinuity = new PolyLine2D(point1, point2);
MaterialInterface2D enrichmentItem = new MaterialInterface2D(discontinuity);
double E1 = 2E6;
double E2 = 0.5 * E1;
double v = 0.3;
var material = BiElasticMaterial2D.CreateMaterialForPlainStrain(E1, v, E2, v, enrichmentItem);
var integrationStrategy = new RectangularSubgridIntegration2D <XContinuumElement2D>(
2, GaussLegendre2D.GetQuadratureWithOrder(2, 2));
//var integrationStrategy = new IntegrationForCrackPropagation2D(GaussLegendre2D.Order2x2,
// new RectangularSubgridIntegration2D<XContinuumElement2D>(2, GaussLegendre2D.Order2x2));
var factory = new XContinuumElement2DFactory(integrationStrategy, integrationStrategy, material);
var element = factory.CreateElement(0, CellType.Quad4, nodes);
//discontinuity.ElementIntersections.Add(element, new CartesianPoint2D[] { point1, point2 });
//OBSOLETE: Elements access their enrichments from nodes now.
//enrichmentItem.EnrichElement(element);
enrichmentItem.EnrichNode(nodes[0]);
enrichmentItem.EnrichNode(nodes[1]);
enrichmentItem.EnrichNode(nodes[2]);
enrichmentItem.EnrichNode(nodes[3]);
return(element);
}
private void InitializeCrack()
{
IPropagator propagator;
if (!writePropagation)
{
propagator = new FixedPropagator(propagationPath, null);
}
else
{
propagator = new Propagator(mesh, jIntegralRadiusOverElementSize,
new HomogeneousMaterialAuxiliaryStates(globalHomogeneousMaterial),
new HomogeneousSIFCalculator(globalHomogeneousMaterial),
new MaximumCircumferentialTensileStressCriterion(), new ConstantIncrement2D(growthLength));
}
var crackMouth = new CartesianPoint(webLeft, crackHeight);
var crackTip = new CartesianPoint(webLeft + crackLength, crackHeight);
var initialCrack = new PolyLine2D(crackMouth, crackTip);
var lsmCrack = new TrackingExteriorCrackLSM(propagator, 0.0, new RelativeAreaResolver(heavisideTol));
lsmCrack.Mesh = mesh;
// Create enrichments
lsmCrack.CrackBodyEnrichment = new CrackBodyEnrichment2D(lsmCrack);
lsmCrack.CrackTipEnrichments = new CrackTipEnrichments2D(lsmCrack, CrackTipPosition.Single);
if (lsmPlotDirectory != null)
{
lsmCrack.EnrichmentLogger = new EnrichmentLogger(Model, lsmCrack, lsmPlotDirectory);
lsmCrack.LevelSetLogger = new LevelSetLogger(Model, lsmCrack, lsmPlotDirectory);
lsmCrack.LevelSetComparer = new PreviousLevelSetComparer(lsmCrack, lsmPlotDirectory);
}
// Mesh geometry interaction
lsmCrack.InitializeGeometry(initialCrack);
this.crack = lsmCrack;
}
internal static IPolyLine2D ConvertTo2D(IPolyLine3D polyline3D)
{
IPolyLine2D polyline2D = new PolyLine2D();
foreach (ISegment3D segment3D in polyline3D.Segments)
{
var segment2D = ConvertTo2D(segment3D);
if (segment2D != null)
{
polyline2D.Segments.Add(segment2D);
}
}
if (polyline3D.IsClosed)
{
polyline2D.StartPoint = new IdaComPoint2D(polyline2D.Segments[polyline2D.Segments.Count - 1].EndPoint.X, polyline2D.Segments[polyline2D.Segments.Count - 1].EndPoint.Y);
}
else
{
polyline2D.StartPoint = new IdaComPoint2D(polyline3D[0].StartPoint.X, polyline3D[0].StartPoint.Y);
}
return(polyline2D);
}
private static float NormalizedMergeInfluence(Tiles tiles, Point2D currentPoint, PolyLine2D lines, Polygon2D polygon)
{
double mergeDistance;
double minDistance = lines.ClosestPointTo(currentPoint).DistanceTo(currentPoint);
if (polygon.EnclosesPoint(currentPoint))
{
mergeDistance = minDistance + tiles.MergeWidth;
}
else
{
mergeDistance = tiles.MergeWidth - minDistance;
if (mergeDistance < 0)
{
mergeDistance = 0;
}
}
float normalizedMergeInfluence = (float)mergeDistance / (tiles.MergeWidth * 2f);
return(normalizedMergeInfluence);
}
public void GetPolyLineLengthTests(string points, double expected)
{
var testElement = new PolyLine2D(from x in points.Split(';') select Point2D.Parse(x));
Assert.AreEqual(expected, testElement.Length);
}
public void InitializeGeometry(PolyLine2D initialCrack)
{
throw new NotImplementedException();
}
private bool draw = false; //描画フラグ
#region UnityEvent
private void Awake()
{
mf = GetComponent <MeshFilter>();
polyLine = new PolyLine2D();
noticeLine = new PolyLine2D();
}
private void InitializeCrack()
{
// Left crack
// Propagator
IPropagator leftPropagator;
if (!writePropagation)
{
leftPropagator = new FixedPropagator(leftPropagationPath, null);
}
else
{
leftPropagator = new Propagator(Mesh, jIntegralRadiusOverElementSize,
new HomogeneousMaterialAuxiliaryStates(globalHomogeneousMaterial),
new HomogeneousSIFCalculator(globalHomogeneousMaterial),
new MaximumCircumferentialTensileStressCriterion(), new ConstantIncrement2D(growthLength));
}
var initialLeftCrack = new PolyLine2D(new CartesianPoint(leftCrackMouthX, leftCrackMouthY),
new CartesianPoint(leftCrackTipX, leftCrackTipY));
LeftCrack = new TrackingExteriorCrackLSM(leftPropagator, tipEnrichmentRadius, new RelativeAreaResolver(heavisideTol));
LeftCrack.Mesh = Mesh;
// Create enrichments
LeftCrack.CrackBodyEnrichment = new CrackBodyEnrichment2D(LeftCrack);
LeftCrack.CrackTipEnrichments = new CrackTipEnrichments2D(LeftCrack, CrackTipPosition.Single);
if (leftLsmPlotDirectory != null)
{
LeftCrack.EnrichmentLogger = new EnrichmentLogger(Model, LeftCrack, leftLsmPlotDirectory);
LeftCrack.LevelSetLogger = new LevelSetLogger(Model, LeftCrack, leftLsmPlotDirectory);
LeftCrack.LevelSetComparer = new PreviousLevelSetComparer(LeftCrack, leftLsmPlotDirectory);
}
// Mesh geometry interaction
LeftCrack.InitializeGeometry(initialLeftCrack);
// Right crack
// Propagator
IPropagator rightPropagator;
if (!writePropagation)
{
rightPropagator = new FixedPropagator(rightPropagationPath, null);
}
else
{
rightPropagator = new Propagator(Mesh, jIntegralRadiusOverElementSize,
new HomogeneousMaterialAuxiliaryStates(globalHomogeneousMaterial),
new HomogeneousSIFCalculator(globalHomogeneousMaterial),
new MaximumCircumferentialTensileStressCriterion(), new ConstantIncrement2D(growthLength));
}
var initialRightCrack = new PolyLine2D(new CartesianPoint(rightCrackMouthX, rightCrackMouthY),
new CartesianPoint(rightCrackTipX, rightCrackTipY));
RightCrack = new TrackingExteriorCrackLSM(rightPropagator, tipEnrichmentRadius, new RelativeAreaResolver(heavisideTol));
RightCrack.Mesh = Mesh;
// Create enrichments
RightCrack.CrackBodyEnrichment = new CrackBodyEnrichment2D(RightCrack);
RightCrack.CrackTipEnrichments = new CrackTipEnrichments2D(RightCrack, CrackTipPosition.Single);
if (rightLsmPlotDirectory != null)
{
RightCrack.EnrichmentLogger = new EnrichmentLogger(Model, RightCrack, rightLsmPlotDirectory);
RightCrack.LevelSetLogger = new LevelSetLogger(Model, RightCrack, rightLsmPlotDirectory);
RightCrack.LevelSetComparer = new PreviousLevelSetComparer(RightCrack, rightLsmPlotDirectory);
}
// Mesh geometry interaction
RightCrack.InitializeGeometry(initialRightCrack);
// Container for both cracks
Crack = new MultipleCracksDisjoint(new TrackingExteriorCrackLSM[] { LeftCrack, RightCrack });
//Crack = new MultipleCracksDisjoint(new TrackingExteriorCrackLSM[] { leftCrack });
}
/// <summary>
/// Constructor
/// </summary>
public CrossSectionGeneralColdFormed()
{
//CenterLine = new List<PolyLine2D>();
Centerline = new PolyLine2D();
}
private void FillTGeneral()
{
//Example of custom T section
CrossSectionComponent css = new CrossSectionComponent();
css.Name = "CSS1";
css.Id = 6;
LineSegment2D seg = null;
//seg = new LineSegment2D(); seg.EndPoint = new Point2D() { X = -0.002, Y = -0.1 }; outline.Segments.Add(seg);
//seg = new LineSegment2D(); seg.EndPoint = new Point2D() { X = 0.002, Y = -0.1 }; outline.Segments.Add(seg);
//seg = new LineSegment2D(); seg.EndPoint = new Point2D() { X = 0.002, Y = -0.002 }; outline.Segments.Add(seg);
//seg = new LineSegment2D(); seg.EndPoint = new Point2D() { X = 0.002, Y = 0.002 }; outline.Segments.Add(seg);
//seg = new LineSegment2D(); seg.EndPoint = new Point2D() { X = 0.002, Y = 0.1 }; outline.Segments.Add(seg);
//seg = new LineSegment2D(); seg.EndPoint = new Point2D() { X = -0.002, Y = 0.1 }; outline.Segments.Add(seg);
//seg = new LineSegment2D(); seg.EndPoint = new Point2D() { X = -0.002, Y = 0.002 }; outline.Segments.Add(seg);
{
CssComponent comp = new CssComponent();
comp.Material = new ReferenceElement(openStructModel.MatSteel.First());
comp.Phase = 0;
var reg = new Region2D();
var outline = new PolyLine2D();
outline.StartPoint = new Point2D()
{
X = -0.15, Y = 0.002
};
seg = new LineSegment2D(); seg.EndPoint = new Point2D()
{
X = -0.15, Y = -0.002
}; outline.Segments.Add(seg);
seg = new LineSegment2D(); seg.EndPoint = new Point2D()
{
X = 0.15, Y = -0.002
}; outline.Segments.Add(seg);
seg = new LineSegment2D(); seg.EndPoint = new Point2D()
{
X = 0.15, Y = 0.002
}; outline.Segments.Add(seg);
seg = new LineSegment2D(); seg.EndPoint = new Point2D()
{
X = -0.15, Y = 0.002
}; outline.Segments.Add(seg);
reg.Outline = outline;
comp.Geometry = reg;
css.Components.Add(comp);
}
{
CssComponent comp = new CssComponent();
comp.Material = new ReferenceElement(openStructModel.MatSteel.First());
comp.Phase = 0;
var reg = new Region2D();
var outline = new PolyLine2D();
outline.StartPoint = new Point2D()
{
X = -0.002, Y = -0.002
};
seg = new LineSegment2D(); seg.EndPoint = new Point2D()
{
X = -0.002, Y = -0.1
}; outline.Segments.Add(seg);
seg = new LineSegment2D(); seg.EndPoint = new Point2D()
{
X = 0.002, Y = -0.1
}; outline.Segments.Add(seg);
seg = new LineSegment2D(); seg.EndPoint = new Point2D()
{
X = 0.002, Y = 0.002
}; outline.Segments.Add(seg);
seg = new LineSegment2D(); seg.EndPoint = new Point2D()
{
X = -0.002, Y = -0.002
}; outline.Segments.Add(seg);
reg.Outline = outline;
comp.Geometry = reg;
css.Components.Add(comp);
}
openStructModel.AddObject(css);
}
public void GetPolyLineLengthTests(string points, double expected)
{
var testElement = new PolyLine2D(from x in points.Split(';') select Point2D.Parse(x));
Assert.AreEqual(expected, testElement.Length);
}
