public static List <PolygonalFace> UnaffectedRefFacesDuringInstallation(SubAssembly newSubAsm) { var insertionDirection = newSubAsm.Install.InstallDirection; //var notAffectedFacesInCom = newSubAsm.Install.Reference.CVXHull.Faces.ToList(); //var halfOfRefCvh = newSubAsm.Install.Reference.CVXHull.Faces.Where(f => f.Normal.dotProduct(insertionDirection) < 0).ToList(); /*foreach (var eachFace in halfOfRefCvh) * { * foreach (var eachMovingVerticies in newSubAsm.Install.Moving.CVXHull.Vertices) * { * var ray = new Ray(eachMovingVerticies, insertionDirection); * var faceAffected = GeometryFunctions.RayIntersectsWithFace(ray, eachFace); * if (faceAffected) * notAffectedFacesInCom.Remove(eachFace); * } * }*/ //return notAffectedFacesInCom; var unaffected1 = newSubAsm.Install.Reference.CVXHull.Faces.Where(f => f.Normal.dotProduct(insertionDirection) > -0.1) .ToList(); /*foreach (var fastener in newSubAsm.Secure.Fasteners) * { * if (fastener.InstallDirection == null) continue; * unaffected1 = unaffected1.Where(f => f.Normal.dotProduct(fastener.InstallDirection) > 0).ToList(); * }*/ return(unaffected1); }
private static double DetermineDistanceToSeparateHull(SubAssembly newSubAsm, Double[] insertionDirection) { var refMaxValue = GeometryFunctions.FindMaxPlaneHeightInDirection(newSubAsm.Install.Reference.CVXHull.Vertices, insertionDirection); var refMinValue = GeometryFunctions.FindMinPlaneHeightInDirection(newSubAsm.Install.Reference.CVXHull.Vertices, insertionDirection); var movingMaxValue = GeometryFunctions.FindMaxPlaneHeightInDirection(newSubAsm.Install.Moving.CVXHull.Vertices, insertionDirection); var movingMinValue = GeometryFunctions.FindMinPlaneHeightInDirection(newSubAsm.Install.Moving.CVXHull.Vertices, insertionDirection); var distanceToFree = Math.Abs(refMaxValue - movingMinValue); if (distanceToFree < 0) { distanceToFree = 0; throw new Exception("How is distance to free less than zero?"); } return(distanceToFree + (movingMaxValue - movingMinValue) + (refMaxValue - refMinValue)); }
//initialize memoization with 2-Component (i.e., arc) subassemblies so heuristic works protected static void InitializeMemo() { foreach (Connection arc in Graph.arcs.Where(a => a is Connection)) { var Asm = new HashSet <Component>(new Component[] { (Component)arc.From, (Component)arc.To }); var Fr = new List <Component>(new Component[] { (Component)arc.From }); var dirs = new HashSet <int>(arc.InfiniteDirections); SubAssembly sa; if (AssemblyEvaluator.EvaluateSub(Graph, Asm, Fr, dirs, out sa) > 0) { HashSet <Component> A = new HashSet <Component>(Asm); MemoData D = new MemoData(sa.Install.Time, sa); Memo.Add(A, D); } } foreach (var node in Graph.nodes) { var component = (Component)node; var N = new HashSet <Component>(new[] { component }); var sa = new SubAssembly(N, EvaluationForBinaryTree.ConvexHullsForParts[component.name], component.Mass, component.Volume, new Vertex(component.CenterOfMass)); MemoData D = new MemoData(0, sa); Memo.Add(N, D); } }
/*private static void BuildingTaskTimeDictionary(SubAssembly subAssembly, double p) * { * if (subAssembly == null) return; * TaskTime.Add(subAssembly.Name, subAssembly.Install.Time); * * BuildingTaskTimeDictionary(subAssembly.Install.Moving as SubAssembly, p); * BuildingTaskTimeDictionary(subAssembly.Install.Reference as SubAssembly, p); * }*/ private static void BuildingFollowingTimeDictionary(SubAssembly subAssembly, double p) { if (subAssembly.Install == null) { return; } FollowingTime.Add(subAssembly.Name, p); var secureTime = 0.0; var movingTime = 0.0; var rotationTime = 0.0; if (subAssembly.Secure != null) { secureTime = 0.2; } //if (subAssembly.MoveRoate != null) movingTime = subAssembly.MoveRoate.Time; if (subAssembly.Rotate != null) { rotationTime = subAssembly.Rotate.Time; } p = p + subAssembly.Install.Time + secureTime + movingTime + rotationTime; BuildingFollowingTimeDictionary(subAssembly.Install.Moving as SubAssembly, p); BuildingFollowingTimeDictionary(subAssembly.Install.Reference as SubAssembly, p); }
public static double CheckStabilityForReference(SubAssembly newSubAsm, FootprintFace f) { var refCOM = newSubAsm.Install.Reference.CenterOfMass; CenterOfMassProjectionOnFootprintFace(f, refCOM); f.MinDisNeaEdg = double.PositiveInfinity; var x02 = f.COMP.Position[0]; var y02 = f.COMP.Position[1]; var z02 = f.COMP.Position[2]; f.Height = Math.Sqrt(Math.Pow(x02 - refCOM.Position[0], 2) + Math.Pow(y02 - refCOM.Position[1], 2) + Math.Pow(z02 - refCOM.Position[2], 2)); foreach (var edge in f.OuterEdges) { var edgeVector = edge.From.Position.subtract(edge.To.Position).normalize(); var distanceOfEdgeToComProj = GeometryFunctions.DistanceBetweenLineAndVertex(edgeVector, edge.From.Position, f.COMP.Position); if (distanceOfEdgeToComProj < f.MinDisNeaEdg) { f.MinDisNeaEdg = distanceOfEdgeToComProj; f.IsComInsideFace = IsTheProjectionInsideOfTheFace(f, edge); } } var spf = Math.Pow(((2 / Math.PI) * (Math.Atan(f.Height / f.MinDisNeaEdg))), 2); f.RefS = spf; return(f.RefS); }
private void UpdateInternalStabilityInfo(SubAssembly sub, List <double> totaldof, double maxsigleDOF, List <double> totalSBscore, double minsigleSB) { sub.InternalStabilityInfo.OverAllDOF = totaldof.Sum(); sub.InternalStabilityInfo.MaxSingleDOF = maxsigleDOF; sub.InternalStabilityInfo.OverAllTippingScore = totalSBscore.Sum(); sub.InternalStabilityInfo.MinSingleTippingScore = minsigleSB; }
internal TreeCandidate(TreeCandidate tc) { parent = tc.parent; sa = tc.sa; RefNodes = tc.RefNodes; MovNodes = tc.MovNodes; G = tc.G; H = tc.H; }
internal static void BuildingInstallationTaskDictionary(SubAssembly subAssembly) { //if (subAssembly == null) return; if (subAssembly.PartNames.Count == 1) { OptimalOrientation.SubAssemAndParts.Add(subAssembly.PartNames[0], subAssembly); } else { OptimalOrientation.SubAssemAndParts.Add(subAssembly.Name, subAssembly); } //if (subAssembly.Install == null) return; if (subAssembly.PartNames.Count == 1) { return; } OptimalOrientation.InstTasks.Add(subAssembly.Name, subAssembly); var secureTime = 0.0; var movingTime = 0.0; var rotationTime = 0.0; if (subAssembly.Secure != null) { secureTime = 0.2; } if (subAssembly.Rotate != null) { rotationTime = subAssembly.Rotate.Time; } var taskTime = subAssembly.Install.Time + secureTime + movingTime + rotationTime; if (double.IsInfinity(taskTime)) { if (double.IsInfinity(subAssembly.Install.Time)) { subAssembly.Install.Time = 5.0; } if (double.IsInfinity(secureTime)) { subAssembly.Install.Time = 5.0; } if (double.IsInfinity(movingTime)) { subAssembly.Install.Time = 5.0; } if (double.IsInfinity(rotationTime)) { subAssembly.Install.Time = 5.0; } taskTime = subAssembly.Install.Time + secureTime + movingTime + rotationTime; } OptimalOrientation.TaskTime.Add(subAssembly.Name, taskTime); BuildingInstallationTaskDictionary(subAssembly.Install.Moving as SubAssembly); BuildingInstallationTaskDictionary(subAssembly.Install.Reference as SubAssembly); }
private Vertex CombinedCenterOfMass(SubAssembly newSubassembly) { return (new Vertex(new[] { (newSubassembly.Install.Moving.CenterOfMass.Position[0] + newSubassembly.Install.Reference.CenterOfMass.Position[0]) / 2, (newSubassembly.Install.Moving.CenterOfMass.Position[1] + newSubassembly.Install.Reference.CenterOfMass.Position[1]) / 2, (newSubassembly.Install.Moving.CenterOfMass.Position[2] + newSubassembly.Install.Reference.CenterOfMass.Position[2]) / 2 })); }
protected static double F(out SubAssembly tree, HashSet <Component> A) { Count[A.Count]++; TimeEstmCounter++; TimeEstm++; if (Memo.ContainsKey(A) /*|| * Memo.Keys.Any(k => k.Count == A.Count && k.All(kk => A.Any(a => a.name == kk.name)))*/) { tree = Memo[A].sa; return(Memo[A].Value); } var candidates = GetCandidates(A); candidates.Sort(); var best = double.PositiveInfinity; SubAssembly bestsa = null, bestReference = null, bestMoving = null; foreach (var tc in candidates) { if (tc.H >= best) { break; } SubAssembly reference, moving; var refTime = F(out reference, tc.RefNodes); var movTime = F(out moving, tc.MovNodes); var maxT = Math.Max(refTime, movTime); var evaluation = tc.sa.Install.Time + maxT; if (evaluation < best) { best = evaluation; bestsa = tc.sa; bestReference = reference; bestMoving = moving; } if (Estimate) { break; } } tree = bestsa; tree.Install.Reference = bestReference; tree.Install.Moving = bestMoving; if (!Estimate) { var d = new MemoData(best, bestsa); Memo.Add(A, d); } return(best); }
private static double StabilityEvaluation(SubAssembly newSubAsm, List <FootprintFace> FootPrintFaces) { double r = 0.0; foreach (var newFa in FootPrintFaces) { r += CheckStabilityForReference(newSubAsm, newFa); } r = r / FootPrintFaces.Count; return(r); }
private static double InitialEvaluation(SubAssembly newSubAsm, double[] installDirection, List <Component> refNodes, List <Component> movingNodes, AssemblyCandidate c, double InstallTime) { newRefCVHFacesInCom.Clear(); var unAffectedFaces = UnaffectedRefFacesDuringInstallation(newSubAsm); var mergedFaces = MergingFaces(unAffectedFaces); c.TimeScore = InstallTime; c.AccessibilityScore = AccessabilityEvaluation(installDirection, mergedFaces); c.StabilityScore = StabilityEvaluation(newSubAsm, mergedFaces); return(c.TimeScore + c.AccessibilityScore + c.StabilityScore); }
/// <summary> /// methods /// </summary> /// internal void Perform(Vertex insertionPoint, double[] insertionDirection, SubAssembly newSubAsm) { // Step #1: Creat ConvexHull Vertices for the SubAssembly //CreateConvexHullVertices(componentsInReference); var insertDir = new[] { insertionDirection[0], insertionDirection[1], insertionDirection[2] }; // Step #2: Compute Accessiblity Metric ComputeAccessibleMetric(insertionPoint, insertDir); // Step #3: Compute Stability Metric ComputeStabilityMetric(insertionPoint, insertDir); }
internal static void PrintAssemblyNodes(SubAssembly Tree) { var R = Tree.Install.Reference.PartNames; var M = Tree.Install.Moving.PartNames; var A = R.Concat(M); Console.Write("[" + Node2Int[A.First()]); foreach (var component in A.Skip(1)) { Console.Write("," + Node2Int[component]); } Console.Write("] (" + A.Count() + ")"); }
internal static void BuildingListOfReferencePreceedings(SubAssembly subAssembly) { //if (subAssembly.Install == null) return; if (subAssembly.PartNames.Count == 1) { return; } OptimalOrientation.RefPrec.Add(subAssembly); //if (subAssembly.Install.Moving.PartNames.Count > 1) var moving = subAssembly.Install.Moving as SubAssembly; OptimalOrientation.TempSucSubassem.Add(subAssembly.Install.Moving.PartNames.Count == 1 ? subAssembly.Install.Moving.PartNames[0] : moving.Name); if (moving.Install != null) { OptimalOrientation.Movings.Add(subAssembly.Install.Moving as SubAssembly); } BuildingListOfReferencePreceedings(subAssembly.Install.Reference as SubAssembly); }
internal static void BuildSuccedingTaskDictionary(SubAssembly subAssembly, List <string> successors) { //if (subAssembly == null) return; if (subAssembly.PartNames.Count == 1) { return; } OptimalOrientation.SucTasks.Add(subAssembly.Name, successors); var subSubAssembly = subAssembly.Install.Moving; var subSuccessors = new List <string>(successors); subSuccessors.Add(subAssembly.Name); BuildSuccedingTaskDictionary(subSubAssembly as SubAssembly, subSuccessors); subSubAssembly = subAssembly.Install.Reference; subSuccessors = new List <string>(successors); subSuccessors.Add(subAssembly.Name); BuildSuccedingTaskDictionary(subSubAssembly as SubAssembly, subSuccessors); }
internal static void PrintTree(SubAssembly Tree, int Level = 0) { if (Tree.Install == null) { return; } Console.Write(String.Concat(Enumerable.Repeat(" ", Level))); PrintAssemblyNodes(Tree); Console.WriteLine(""); if (Tree.Install.Reference.PartNames.Count > 1) { PrintTree((SubAssembly)Tree.Install.Reference, Level + 1); } if (Tree.Install.Moving.PartNames.Count > 1) { PrintTree((SubAssembly)Tree.Install.Moving, Level + 1); } }
private HashSet <Double[]> InsertionDirectionsFromRemovalDirections(SubAssembly sub, List <Component> optNodes, HashSet <int> validDirs) { // Note: The hashset of validDirs are the removal directions to remove optNodes from the rest. // If the optNodes is the reference, then the installDirections are the same as validDirs // If the optNodes is the moving, then the InstallDirection is the opposite of the validDirs var dirs = new HashSet <Double[]>(); if (sub.Install.Reference.PartNames.All(optNodes.Select(n => n.name).ToList().Contains) && optNodes.Select(n => n.name).ToList().All(sub.Install.Reference.PartNames.Contains)) { foreach (var dir in validDirs) { dirs.Add(DisassemblyDirections.Directions[dir]); } return(dirs); } foreach (var dir in validDirs) { dirs.Add(DisassemblyDirections.Directions[dir].multiply(-1.0)); } return(dirs); }
public MemoData(double V, SubAssembly S) { Value = V; sa = S; }
public SubAssembly Update(option opt, List <Component> rest, Dictionary <string, TVGLConvexHull> convexHullForParts) { Part refAssembly, movingAssembly; //if (ActionIsAssemblyByAssembly()) //{ // //var node0 = (Component)opt.nodes[0]; // //var node1 = (Component)opt.nodes[1]; // //var node0name = node0.name; // //var node1name = node1.name; // //refAssembly = Subassemblies.FirstOrDefault(subasm => subasm.PartNames.Contains(node0name)); // //if (refAssembly == null) // // refAssembly = new Part(node0name, GetPartMass(node0), GetPartVolume(node0), // // convexHullForParts[node0name], GetPartCenterOfMass(node0)); // //else Subassemblies.Remove((SubAssembly) refAssembly); // //movingAssembly = Subassemblies.FirstOrDefault(subasm => subasm.PartNames.Contains(node1name)); // //if (movingAssembly == null) // // movingAssembly = new Part(node1name, GetPartMass(node1), GetPartVolume(node1), // // convexHullForParts[node1name], GetPartCenterOfMass(node0)); // //else Subassemblies.Remove((SubAssembly) movingAssembly); //} //else if (ActionIsRemoveSCC()) //{ var movingNodes = opt.Nodes.Cast <Component>().ToList(); var newSubAsmNodes = rest; if (movingNodes.Count == 1) { var nodeName = movingNodes[0].name; movingAssembly = new Part(nodeName, GetPartMass(movingNodes[0]), GetPartVolume(movingNodes[0]), convexHullForParts[nodeName], GetPartCenterOfMass(movingNodes[0])); } else { var combinedCVXHullM = CreateCombinedConvexHull2(movingNodes, convexHullForParts); var VolumeM = GetSubassemblyVolume(movingNodes); var MassM = GetSubassemblyMass(movingNodes); var centerOfMass = GetSubassemblyCenterOfMass(movingNodes); movingAssembly = new SubAssembly(new HashSet <Component>(movingNodes), combinedCVXHullM, MassM, VolumeM, centerOfMass); } var referenceHyperArcnodes = new List <Component>(); referenceHyperArcnodes = newSubAsmNodes.Where(a => !movingNodes.Contains(a)).ToList(); if (referenceHyperArcnodes.Count == 1) { var nodeName = referenceHyperArcnodes[0].name; refAssembly = new Part(nodeName, GetPartMass(referenceHyperArcnodes[0]), GetPartVolume(referenceHyperArcnodes[0]), convexHullForParts[nodeName], GetPartCenterOfMass(referenceHyperArcnodes[0])); } else { var combinedCVXHullR = CreateCombinedConvexHull2(referenceHyperArcnodes, convexHullForParts); var VolumeR = GetSubassemblyVolume(referenceHyperArcnodes); var MassR = GetSubassemblyMass(referenceHyperArcnodes); var centerOfMass = GetSubassemblyCenterOfMass(referenceHyperArcnodes); refAssembly = new SubAssembly(new HashSet <Component>(referenceHyperArcnodes), combinedCVXHullR, MassR, VolumeR, centerOfMass); } //} //else throw new Exception("Only install rules in assembly at this point."); TVGLConvexHull combinedCVXHull = CreateCombinedConvexHull( refAssembly.CVXHull, movingAssembly.CVXHull); //List<PolygonalFace> refFacesInCombined, movingFacesInCombined; var InstallCharacter = shouldReferenceAndMovingBeSwitched(refAssembly, movingAssembly, combinedCVXHull, out refFacesInCombined, out movingFacesInCombined); if ((int)InstallCharacter < 0) { var tempASM = refAssembly; refAssembly = movingAssembly; movingAssembly = tempASM; refFacesInCombined = movingFacesInCombined; // no need to use temp here, as the movingFaces in the // combined convex hull are not needed. InstallCharacter = (InstallCharacterType)(-((int)InstallCharacter)); } string refName = NameMaker(refAssembly); string movName = NameMaker(movingAssembly); var newSubassembly = new SubAssembly(refAssembly, movingAssembly, combinedCVXHull, InstallCharacter, refFacesInCombined); //newSubassembly.Name = refName +" on "+movName; newSubassembly.CenterOfMass = CombinedCenterOfMass(newSubassembly); // instead of adding to Subassemblies, newSubassembly must be added to its preceeding subassembly (to its parent) Subassemblies.Add(newSubassembly); return(newSubassembly); }
public const double TRANSFERSPEED = 0.8; // Transfer Speed: 0.1 (m/sec) public List <double> EvaluateTimeAndSDForInstall(List <Connection> connectingArcs, double travelDistance, double insertionDistance, SubAssembly newSubAsm) { // 1. Install units are in kg and m // a. travel time var TimeAndSD = new List <double>(); var movingMass = newSubAsm.Install.Moving.Mass / 1000; var movingVol = newSubAsm.Install.Moving.Volume / 1000000; //var movingVol = 1; var movingSpeed = new double(); //var movingSpeed = 15.0; if (movingMass <= 1) { movingSpeed = 1; } else if (movingSpeed > 1 && movingSpeed <= 15) { movingSpeed = movingMass * (-8.0 / 140000.0) + 148.0 / 140.0; } else { movingSpeed = 0.2; } var traveltime = travelDistance / movingSpeed; var DisTraveltime = 0.05; // b. contact info var insertiontime = new double(); var aligmentime = new double(); var DisAligmentime = new double(); if (movingVol <= 0.000001) { aligmentime = -4008 * movingVol + 5; DisAligmentime = 1; } else if (movingVol <= 0.001) { aligmentime = 3; DisAligmentime = 1; } else { aligmentime = 54.1 * movingVol + 2.95; DisAligmentime = movingVol * 50 + movingMass / 100; } if (insertionDistance != 0) { insertiontime = (insertionDistance / 1000) / Constants.MaxInsertionSpeed; } double installationTime = traveltime + aligmentime + insertiontime; double Disinstalltime = DisTraveltime + DisAligmentime; // c. still need statbility //2. Secure: var bolttime = new double(); var DisBolttime = new double(); foreach (var a in connectingArcs.Where(a => a.localVariables.Contains(DisConstants.BoltDepth))) { var boltLength = a.localVariables[a.localVariables.IndexOf(DisConstants.BoltDepth) + 1]; bolttime = bolttime + boltLength / Constants.boltinsertSpeed; DisBolttime = DisBolttime + bolttime - boltLength / (Constants.boltinsertSpeed + 0.2); } installationTime = installationTime + bolttime; Disinstalltime = Disinstalltime + DisBolttime; TimeAndSD.Add(installationTime); TimeAndSD.Add(Disinstalltime); return(TimeAndSD); }
protected static void InitializeMemoBoosted() { var newMemo = new List <HashSet <HashSet <Component> > >(); for (var i = 1; i <= Graph.nodes.Count; i++) { var combinations = CombinationFinder(i); var column = new HashSet <HashSet <Component> >(); if (!combinations.Any()) { foreach (var node in Graph.nodes) { var component = (Component)node; var N = new HashSet <Component>(new[] { component }); var sa = new SubAssembly(N, EvaluationForBinaryTree.ConvexHullsForParts[component.name], component.Mass, component.Volume, new Vertex(component.CenterOfMass)); var D = new MemoData(0, sa); column.Add(N); Memo.Add(N, D); } newMemo.Add(column); } else { Parallel.ForEach(combinations, comb => { foreach (var subAssem1 in newMemo[comb[0] - 1]) { foreach (var subAssem2 in newMemo[comb[1] - 1]) { if (subAssem1.Any(subAssem2.Contains)) { continue; } var connections = new HashSet <Connection>( subAssem1.SelectMany( n => n.arcs.Where(c => c is Connection).Cast <Connection>().Where(c => (subAssem1.Contains(c.From) && subAssem2.Contains(c.To)) || (subAssem1.Contains(c.To) && subAssem2.Contains(c.From))))); var secConnections = new HashSet <SecondaryConnection>( subAssem1.SelectMany( n => n.arcs.Where(a => a is SecondaryConnection) .Cast <SecondaryConnection>() .Where(c => (subAssem1.Contains(c.From) && subAssem2.Contains(c.To)) || (subAssem1.Contains(c.To) && subAssem2.Contains(c.From))))); if (!connections.Any()) { continue; } var dirs = ValidDirectionsFinder(subAssem1, subAssem2, connections); ApplySecondaryConnections(dirs, subAssem1, subAssem2, secConnections); if (!dirs.Any()) { continue; } var asm = new HashSet <Component>(subAssem1); asm.UnionWith(subAssem2); SubAssembly sa; if (AssemblyEvaluator.EvaluateSub(Graph, asm, subAssem1.ToList(), dirs, out sa) > 0) { if (!Memo.ContainsKey(asm)) { var D = new MemoData(sa.Install.Time, sa); lock (Memo) Memo.Add(asm, D); lock (column) column.Add(asm); continue; } if (sa.Install.Time < Memo[asm].Value) { lock (Memo) Memo[asm] = new MemoData(sa.Install.Time, sa); } } } } }); newMemo.Add(column); if (newMemo.Count == 3) { break; } } } }
/// <summary> /// returns the subassembly class given the two lists of components /// </summary> /// <param name="opt">The opt.</param> /// <param name="rest">The rest.</param> /// <returns>SubAssembly.</returns> public SubAssembly Update(List <Component> opt, List <Component> rest) { //todo: change List to HashSet Part refAssembly, movingAssembly; var movingNodes = opt; var newSubAsmNodes = rest; if (movingNodes.Count == 1) { var nodeName = movingNodes[0].name; movingAssembly = new SubAssembly(new HashSet <Component>(movingNodes), ConvexHullsForParts[nodeName], movingNodes[0].Mass, movingNodes[0].Volume, new Vertex(movingNodes[0].CenterOfMass)); //movingAssembly = new Part(nodeName, movingNodes[0].Volume, movingNodes[0].Volume, // ConvexHullsForParts[nodeName], new Vertex(movingNodes[0].CenterOfMass)); } else { var combinedCVXHullM = CreateCombinedConvexHull2(movingNodes); var VolumeM = GetSubassemblyVolume(movingNodes); var MassM = GetSubassemblyMass(movingNodes); var centerOfMass = GetSubassemblyCenterOfMass(movingNodes); movingAssembly = new SubAssembly(new HashSet <Component>(movingNodes), combinedCVXHullM, MassM, VolumeM, centerOfMass); } var referenceHyperArcnodes = new List <Component>(); referenceHyperArcnodes = (List <Component>)newSubAsmNodes.Where(a => !movingNodes.Contains(a)).ToList(); if (referenceHyperArcnodes.Count == 1) { var nodeName = referenceHyperArcnodes[0].name; refAssembly = new SubAssembly(new HashSet <Component>(referenceHyperArcnodes), ConvexHullsForParts[nodeName], referenceHyperArcnodes[0].Mass, referenceHyperArcnodes[0].Volume, new Vertex(referenceHyperArcnodes[0].CenterOfMass)); //refAssembly = new Part(nodeName, referenceHyperArcnodes[0].Mass, referenceHyperArcnodes[0].Volume, // ConvexHullsForParts[nodeName], // new Vertex(referenceHyperArcnodes[0].CenterOfMass)); } else { var combinedCVXHullR = CreateCombinedConvexHull2(referenceHyperArcnodes); var VolumeR = GetSubassemblyVolume(referenceHyperArcnodes); var MassR = GetSubassemblyMass(referenceHyperArcnodes); var centerOfMass = GetSubassemblyCenterOfMass(referenceHyperArcnodes); refAssembly = new SubAssembly(new HashSet <Component>(referenceHyperArcnodes), combinedCVXHullR, MassR, VolumeR, centerOfMass); } var combinedCvxHull = CreateCombinedConvexHull(refAssembly.CVXHull, movingAssembly.CVXHull); List <PolygonalFace> movingFacesInCombined; List <PolygonalFace> refFacesInCombined; var InstallCharacter = shouldReferenceAndMovingBeSwitched(refAssembly, movingAssembly, combinedCvxHull, out refFacesInCombined, out movingFacesInCombined); if ((int)InstallCharacter < 0) { var tempASM = refAssembly; refAssembly = movingAssembly; movingAssembly = tempASM; refFacesInCombined = movingFacesInCombined; // no need to use temp here, as the movingFaces in the // combined convex hull are not needed. InstallCharacter = (InstallCharacterType)(-((int)InstallCharacter)); } var newSubassembly = new SubAssembly(refAssembly, movingAssembly, combinedCvxHull, InstallCharacter, refFacesInCombined); newSubassembly.CenterOfMass = CombinedCenterOfMass(newSubassembly); return(newSubassembly); }
/// <summary> /// Evaluates the subassemly. /// </summary> /// <param name="subassemblyNodes">The subassembly nodes - all the nodes in the combined install action.</param> /// <param name="optNodes">The subset of nodes that represent one of the two parts in the install step.</param> /// <param name="sub">The sub is the class that is then tied into the treequence.</param> /// <returns>System.Double.</returns> public double EvaluateSub(designGraph graph, HashSet <Component> subassemblyNodes, List <Component> optNodes, HashSet <int> validDirs, out SubAssembly sub) { var rest = subassemblyNodes.Where(n => !optNodes.Contains(n)).ToList(); sub = Update(optNodes, rest); var connectingArcs = graph.arcs.Where(a => a is Connection) .Cast <Connection>() .Where(a => ((optNodes.Contains(a.To) && rest.Contains(a.From)) || (optNodes.Contains(a.From) && rest.Contains(a.To)))) .ToList(); var insertionDirections = InsertionDirectionsFromRemovalDirections(sub, optNodes, validDirs); var minDis = double.PositiveInfinity; var bestInstallDirection = new[] { 0.0, 0.0, 0.0 }; foreach (var dir in insertionDirections) { var dis = DetermineDistanceToSeparateHull(sub, dir); if (dis >= minDis) { continue; } minDis = dis; bestInstallDirection = dir; } sub.Install.InstallDirection = bestInstallDirection; sub.Install.InstallDistance = minDis; // I need to add InstallationPoint also var install = new[] { rest, optNodes }; if (EitherRefOrMovHasSeperatedSubassemblies(install, subassemblyNodes)) { return(-1); } var moivingnames = sub.Install.Moving.PartNames; var refnames = sub.Install.Reference.PartNames; var movingnodes = subassemblyNodes.Where(n => moivingnames.Contains(n.name)).ToList(); var refnodes = subassemblyNodes.Where(n => refnames.Contains(n.name)).ToList(); /////time sub.Install.Time = 0; EvaluateSubFirstThreeTime(sub, refnodes, movingnodes, minDis, out sub.Install.Time, out sub.Install.TimeSD, out sub.Secure.Time, out sub.Secure.TimeSD); if (sub.Install.Time < 0) { sub.Install.Time = 0.5; } ///////stability //assembly gravity direction is oppositve to install directon var Gravitydir = bestInstallDirection.multiply(-1); var stbility1 = Stabilityfunctions.EvaluateSubStability(Program.AssemblyGraph, refnodes, movingnodes, sub, Gravitydir); if (refnodes.Count == 1) { stbility1 = -1; } var stbility2 = Stabilityfunctions.EvaluateSubStability(Program.AssemblyGraph, movingnodes, refnodes, sub, Gravitydir); if (movingnodes.Count == 1) { stbility2 = -1; } var stbility = stbility1 + stbility2; sub.InternalStabilityInfo.Totalsecore = stbility; sub.Secure.Fasteners = ConnectingArcsFastener(connectingArcs, subassemblyNodes, optNodes); return(1); }
public static void EvaluateSubFirstThreeTime(SubAssembly sub, List <Component> refnodes, List <Component> movingnodes, double olpdis, out double totaltime, out double totalSD, out double securetime, out double securesd) { var inputunitscaler = Program.MeshMagnifier / 1000;//magnifier translate unit to cm var movingsolids = new List <TessellatedSolid>(); var referencesolids = new List <TessellatedSolid>(); var movingvertex = new List <Vertex>(); var counter = 10e6; /////// ///moving /////// foreach (var n in movingnodes) { movingsolids.Add(Program.Solids[n.name][0]); //cheange bbbbb class } foreach (var v in sub.Install.Moving.CVXHull.Vertices) { movingvertex.Add(v); } var movingOBB = OBB.BuildUsingPoints(movingvertex); // var movingOBB = OBB.BuildUsingPoints(movingvertex); var lengths = new double[] { StarMath.norm1(movingOBB.CornerVertices[0].Position.subtract(movingOBB.CornerVertices[1].Position)), StarMath.norm1(movingOBB.CornerVertices[2].Position.subtract(movingOBB.CornerVertices[1].Position)), StarMath.norm1(movingOBB.CornerVertices[0].Position.subtract(movingOBB.CornerVertices[4].Position)), }; var lmax = lengths.Max() / inputunitscaler; //mm var lmin = lengths.Min() / inputunitscaler; //mm double lmid = lengths.Average() / inputunitscaler * 3 - lmax - lmin; var movingweight = Math.Log(sub.Install.Moving.Mass / inputunitscaler / Math.Pow(inputunitscaler, 3)); //in g ??????????? var OBBvolue = Math.Log(movingOBB.Volume / 1000 / Math.Pow(inputunitscaler, 3)); //cm^3 var OBBmaxsurface = Math.Log(lmax * lmid / 1000); var OBBminsurface = Math.Log(lmin * lmid / 1000); ///// /// distance TBD var movingdistance = 50;//cm var movingdis = Math.Log(movingdistance); var movinginput = new double[5] { movingweight, OBBvolue, OBBmaxsurface, OBBminsurface, movingdis }; sub.MoveRoateModelInputs = OnlineGPupdating.RowtoMatrix(movinginput); // Log ( weight, OOBvol OBB, maxf OBB, minf moving, distance )all in mmgs unit system double movingtime = 0.0; double movingSD = 0.0; CalculateAssemblyTimeAndSD.GetTimeAndSD(sub, movinginput, "moving", out movingtime, out movingSD); // Program.allmtime.Add(movingtime); /////// ///install /////// var allolpfs = BlockingDetermination.OverlappingSurfaces.FindAll( s => (movingnodes.Any(n => n.name.Equals(s.Solid1.Name))) && (refnodes.Any(n => n.name.Equals(s.Solid2.Name))) || (movingnodes.Any(n => n.name.Equals(s.Solid2.Name))) && (refnodes.Any(n => n.name.Equals(s.Solid1.Name))) ); double olpfeatures = 0.0; for (int i = 0; i < allolpfs.Count; i++) { olpfeatures += allolpfs[i].Overlappings.Count; ////no alignment features for now; } if (olpfeatures == 0) { olpfeatures = 0.3; } var logOverlappingDist = Math.Log(olpdis / inputunitscaler); if (double.IsInfinity(logOverlappingDist)) { logOverlappingDist = 1e-6; } var installinput = new double[6] { movingweight, OBBvolue, OBBmaxsurface, OBBminsurface, logOverlappingDist, Math.Log(olpfeatures) }; sub.InstallModelInputs = OnlineGPupdating.RowtoMatrix(installinput); double installtime = 0; double instalSD = 0; CalculateAssemblyTimeAndSD.GetTimeAndSD(sub, installinput, "install", out installtime, out instalSD); //Program.allitime.Add(installtime); /////// ///secure /////// securetime = 0.0; securesd = 0.0; if (sub.Secure.Fasteners != null) { foreach (var f in sub.Secure.Fasteners) { double eachseucretime = 0; double eachsecureSD = 0; var secureinput = new double[6]; if (f.SecureModelInputs == null) { var OBBmax = (f.Diameter / inputunitscaler) * (f.OverallLength / inputunitscaler); var OBBmin = (f.Diameter / inputunitscaler) * (f.Diameter / inputunitscaler); var numberofthreads = f.NumberOfThreads; if (numberofthreads == 0) { numberofthreads = 10; } var insertdistance = f.EngagedLength / inputunitscaler * 0.5; if (insertdistance == 0) { insertdistance = numberofthreads * 0.25; } var nut = 1; var tool = 2; if (f.Nuts != null) { nut = 2; } secureinput = new double[6] { Math.Log(OBBmax / 1000), Math.Log(OBBmin / 1000), Math.Log(numberofthreads), Math.Log(insertdistance), nut, tool }; f.SecureModelInputs = OnlineGPupdating.RowtoMatrix(secureinput); } else { secureinput = OnlineGPupdating.MatrixtoRow(f.SecureModelInputs); } CalculateAssemblyTimeAndSD.GetTimeAndSD(sub, secureinput, "s", out eachseucretime, out eachsecureSD); securetime += eachseucretime; securesd += eachsecureSD; f.Time = eachseucretime; f.TimeSD = eachsecureSD; // if (eachseucretime > 30) // { // var sssss = 1; // } //// if (securetime != 0) // // Bridge.gpsecuretime.Add(eachseucretime); } } if (installtime < 0) { installtime = 0.5; } if (movingtime < 0) { movingtime = 0.5; } sub.MoveRoate.Time = movingtime; sub.MoveRoate.TimeSD = movingSD; totalSD = instalSD + movingSD; sub.Install.Time = installtime; sub.Install.TimeSD = totalSD; sub.Secure.Time = securetime; sub.Secure.TimeSD = securesd; totaltime = installtime + movingtime; if (movingtime > 2.9 && movingtime < 3.01) { var sss = 1; } if (installtime > 2.9 && installtime < 3.01) { var sss = 1; } // Bridge.gpinstalltime.Add(installtime); // Bridge.gpmovingtime.Add(movingtime); }
internal static AssemblySequence Run(designGraph graph, Dictionary <string, List <TessellatedSolid> > solids, List <int> globalDirPool, bool DoEstimate = false) { Constants.Values = new Constants(); //if (Bridge.RestartBoolean) ClearEveryThing(); Graph = graph; AssemblyEvaluator = new EvaluationForBinaryTree(solids); DirPool = globalDirPool; //Updates.UpdateGlobalDirections(DirPool); Estimate = DoEstimate; TimeEstmCounter++; TimeEstm++; SubAssembly tree = null; var watch = new Stopwatch(); watch.Start(); /* * InitializeMemoBoosted(); * var best = F(out tree, new HashSet<Component>(Graph.nodes.Cast<Component>())); */ #if SerialDebug InitializeMemo(); var best = F(out tree, new HashSet <Component>(Graph.nodes.Cast <Component>())); #else Task.Factory.StartNew(() => InitializeMemoBoosted()); Task.Factory.StartNew(() => { var best = F(out tree, new HashSet <Component>(Graph.nodes.Cast <Component>())); }); Task.WaitAll(); #endif watch.Stop(); //var index = 0; //foreach (var component in Graph.nodes.Cast<Component>()) //{ // Node2Int[component.name] = index++; //for use with PrintTree //} //redo: /*var frozen = new HashSet<Component>(); * foreach (var n in tree.Install.Moving.PartNames) * frozen.Add((Component) Graph.nodes.First(nod => nod.name == n)); * FrozenSequence.Add(frozen); * * foreach (var seq in FrozenSequence) * { * var last = Graph.addHyperArc(seq.Cast<node>().ToList()); * last.localLabels.Add(DisConstants.gSCC); * }*/ // when the code is running again with frozen subassemblies, keep the memo of each frozen sub, // the ones with and 2 nodeas and and remove the rest. //UpdateTheMemo(); //goto redo; //Console.WriteLine("Best assembly time found: " + Best); //for (int i = 1; i <= Graph.nodes.Count; i++) // Console.WriteLine(i+" "+Count[i]); //PrintTree(Tree); return(new AssemblySequence { Subassemblies = new List <SubAssembly> { tree } }); //return Tree; }