private void CreateNewTagForPointLoad(View activeV, XYZ loadPosition, PointLoad pl) { Transaction t = new Transaction(_doc); t.Start("Create tag for point load"); TagMode tagMode = TagMode.TM_ADDBY_CATEGORY; TagOrientation tagorn = TagOrientation.Horizontal; IndependentTag tag = IndependentTag.Create(_doc, activeV.Id, new Reference(pl), false, tagMode, tagorn, loadPosition); FamilySymbol tagType = (from fs in new FilteredElementCollector(_doc) .OfCategory(BuiltInCategory.OST_PointLoadTags) .OfClass(typeof(FamilySymbol)) .Cast <FamilySymbol>() where fs.Name.Equals(Default.TYPE_NAME_POINT_LOAD) select fs) .FirstOrDefault(); if (tagType != null) { tag.ChangeTypeId(tagType.Id); } t.Commit(); AssociateTagToPointLoad(pl, tag); }
private void AssociateTagToPointLoad(PointLoad pl, IndependentTag tag) { using (Transaction trans = new Transaction(_doc, "Create Extensible Store")) { trans.Start(); SchemaBuilder builder = new SchemaBuilder(Guids.POINTLOAD_SHEMA_GUID); builder.SetReadAccessLevel(AccessLevel.Public); builder.SetWriteAccessLevel(AccessLevel.Public); builder.SetSchemaName("Tag"); builder.SetDocumentation("The tag linked to the point load"); // Create field1 FieldBuilder fieldBuilder1 = builder.AddSimpleField("Tag", typeof(ElementId)); // Register the schema object Schema schema = builder.Finish(); Field tagField = schema.GetField("Tag"); Entity ent = new Entity(schema); ent.Set(tagField, tag.Id); pl.SetEntity(ent); trans.Commit(); } }
/***************************************************/ private bool CreateLoad(PointLoad bhLoad) { List <Node> nodes = bhLoad.Objects.Elements.ToList(); string loadPat = GetAdapterId <string>(bhLoad.Loadcase); string cSys = bhLoad.Axis.ToCSI(); double[] val = { bhLoad.Force.X, bhLoad.Force.Y, bhLoad.Force.Z, bhLoad.Moment.X, bhLoad.Moment.Y, bhLoad.Moment.Z, }; bool replace = SAPPushConfig.ReplaceLoads; foreach (Node bhNode in nodes) { if (m_model.PointObj.SetLoadForce(GetAdapterId <string>(bhNode), loadPat, ref val, replace, cSys, eItemType.Objects) != 0) { CreateElementError("Point Load", bhLoad.Name); } } SetAdapterId(bhLoad, null); return(true); }
/***************************************************/ private List <ILoad> ReadPointLoad(List <Loadcase> loadcases) { List <ILoad> bhLoads = new List <ILoad>(); Dictionary <string, Node> bhomNodes = ReadNode().ToDictionary(x => GetAdapterId <string>(x)); string[] names = null; string[] loadcase = null; string[] CSys = null; int[] step = null; int nameCount = 0; double[] fx = null; double[] fy = null; double[] fz = null; double[] mx = null; double[] my = null; double[] mz = null; if (m_model.PointObj.GetLoadForce("All", ref nameCount, ref names, ref loadcase, ref step, ref CSys, ref fx, ref fy, ref fz, ref mx, ref my, ref mz, eItemType.Group) != 0) { return(bhLoads); } for (int i = 0; i < nameCount; i++) { if (CSys[i] != "Global") { Engine.Base.Compute.RecordWarning($"The coordinate system: {CSys[i]} was not read. The PointLoads defined in the coordinate system: {CSys[i]} were set as Global"); } Loadcase bhLoadcase = loadcases.FirstOrDefault(x => x.Name == loadcase[i]); if (bhLoadcase == null) { continue; } PointLoad bhLoad = new PointLoad() { Force = new Vector() { X = fx[i], Y = fy[i], Z = fz[i] }, Moment = new Vector() { X = mx[i], Y = my[i], Z = mz[i] }, Loadcase = bhLoadcase, Objects = new BHoMGroup <Node>() { Elements = { bhomNodes[names[i]] } } }; bhLoads.Add(bhLoad); } return(bhLoads); }
/***************************************************/ /**** Private Methods ****/ /***************************************************/ private IFLoadingConcentrated CreateConcentratedLoad(PointLoad pointLoad, object[] lusasPoints) { IFLoadingConcentrated lusasPointLoad; IFLoadcase assignedLoadcase = (IFLoadcase)d_LusasData.getLoadset(pointLoad.Loadcase.AdapterId <int>(typeof(LusasId))); if (d_LusasData.existsAttribute("Loading", pointLoad.Name)) { lusasPointLoad = (IFLoadingConcentrated)d_LusasData.getAttribute("Loading", pointLoad.Name); } else { lusasPointLoad = d_LusasData.createLoadingConcentrated(pointLoad.Name); lusasPointLoad.setConcentrated( pointLoad.Force.X, pointLoad.Force.Y, pointLoad.Force.Z, pointLoad.Moment.X, pointLoad.Moment.Y, pointLoad.Moment.Z); } IFAssignment lusasAssignment = m_LusasApplication.assignment(); lusasAssignment.setLoadset(assignedLoadcase); lusasPointLoad.assignTo(lusasPoints, lusasAssignment); int adapterIdName = lusasPointLoad.getID(); pointLoad.SetAdapterId(typeof(LusasId), adapterIdName); return(lusasPointLoad); }
/***************************************************/ /**** Private methods ****/ /***************************************************/ private bool CreateObject(PointLoad pointLoad) { int err = 0; int loadCaseId = GetAdapterId <int>(pointLoad); double[] forces = new double[3]; double[] moments = new double[3]; forces[0] = pointLoad.Force.X; forces[1] = pointLoad.Force.Y; forces[2] = pointLoad.Force.Z; moments[0] = pointLoad.Moment.X; moments[1] = pointLoad.Moment.Y; moments[2] = pointLoad.Moment.Z; foreach (Node node in pointLoad.Objects.Elements) { int nodeId = GetAdapterId <int>(node); err = St7.St7SetNodeForce3(1, nodeId, loadCaseId, forces); if (!St7ErrorCustom(err, "Couldn't set point load for a loadcase " + loadCaseId + " node " + nodeId)) { return(false); } err = St7.St7SetNodeMoment3(1, nodeId, loadCaseId, moments); if (!St7ErrorCustom(err, "Couldn't set point load for a loadcase " + loadCaseId + " node " + nodeId)) { return(false); } } return(true); }
public void AssociateLoadToFoundation(FamilyInstance foundation, PointLoad pointLoad) { using (Transaction trans = new Transaction(_doc, "Create Extensible Store")) { trans.Start(); SchemaBuilder builder = new SchemaBuilder(Guids.FOUNDATION_SHEMA_GUID); builder.SetReadAccessLevel(AccessLevel.Public); builder.SetWriteAccessLevel(AccessLevel.Public); builder.SetSchemaName("PointLoad"); builder.SetDocumentation("The point load linked to the foundation"); // Create field1 FieldBuilder fieldBuilder1 = builder.AddSimpleField("PointLoad", typeof(ElementId)); // Register the schema object Schema schema = builder.Finish(); Field pointLoadField = schema.GetField("PointLoad"); Entity ent = new Entity(schema); ent.Set(pointLoadField, pointLoad.Id); foundation.SetEntity(ent); trans.Commit(); } }
public static List <ICurve> Visualize(this PointLoad pointForce, double scaleFactor = 1.0, bool displayForces = true, bool displayMoments = true, bool asResultants = true) { if (pointForce.IsNull()) { return(null); } List <ICurve> arrows = new List <ICurve>(); Vector forceVec = pointForce.Force * scaleFactor; Vector momentVec = pointForce.Moment * scaleFactor; foreach (Node node in pointForce.Objects.Elements) { if (displayForces) { arrows.AddRange(Arrows(node.Position, forceVec, true, asResultants)); } if (displayMoments) { arrows.AddRange(Arrows(node.Position, momentVec, false, asResultants)); } } return(arrows); }
//Fill loads to nodal load component private static void fillComponent(ref NodalLoadComponent component, PointLoad kPLoad) { component.Force = new Point3D { X = kPLoad.force.X * 1000, Y = kPLoad.force.Y * 1000, Z = kPLoad.force.Z * 1000 }; component.Moment = new Point3D { X = kPLoad.moment.X * 1000, Y = kPLoad.moment.Y * 1000, Z = kPLoad.moment.Z * 1000 }; }
private PointLoad CreateNewLoadForFoundation(FamilyInstance foundation, XYZ loadPosition, XYZ force, XYZ moment) { PointLoad pl; Transaction t = new Transaction(_doc); t.Start("Creat point load"); pl = PointLoad.Create(_doc, loadPosition, force, moment, null, null); t.Commit(); AssociateLoadToFoundation(foundation, pl); return(pl); }
public static void SetLoad(cSapModel model, PointLoad pointLoad, bool replace) { double[] pfValues = new double[] { pointLoad.Force.X, pointLoad.Force.Y, pointLoad.Force.Z, pointLoad.Moment.X, pointLoad.Moment.Y, pointLoad.Moment.Z }; int ret = 0; foreach (Node node in pointLoad.Objects.Elements) { string csiCaseName = CaseNameToCSI(pointLoad.Loadcase); ret = model.PointObj.SetLoadForce(node.CustomData[AdapterId].ToString(), csiCaseName, ref pfValues, replace); } }
/***************************************************/ public void SetLoad(PointLoad pointLoad, bool replace) { if (pointLoad.Axis != LoadAxis.Global) { Engine.Base.Compute.RecordWarning("The local coordinate system of BHoM nodes are not pushed to ETABS, Local Axis PointLoads are set on the Global Axis"); } double[] pfValues = new double[] { pointLoad.Force.X, pointLoad.Force.Y, pointLoad.Force.Z, pointLoad.Moment.X, pointLoad.Moment.Y, pointLoad.Moment.Z }; int ret = 0; foreach (Node node in pointLoad.Objects.Elements) { string caseName = GetAdapterId <string>(pointLoad.Loadcase); string nodeName = GetAdapterId <string>(node); ret = m_model.PointObj.SetLoadForce(nodeName, caseName, ref pfValues, replace); } }
public FactorPointLoadDialog(SlopeDefineCanvas canvas, PointLoad load) { InitializeComponent(); this.canvas = canvas; this.load = load; // get units dependent scaling factor and strings double factor; string coordUnits, loadUnits; switch (canvas.Units) { case Units.Metres: factor = 0.0254; coordUnits = "m"; loadUnits = "kN"; break; case Units.Millimetres: factor = 25.4; coordUnits = "mm"; loadUnits = "kN"; break; case Units.Feet: factor = 1.0 / 12.0; coordUnits = "ft"; loadUnits = "lbf"; break; default: factor = 1.0; coordUnits = "in"; loadUnits = "lbf"; break; } // set units labels nodeUnits.Content = coordUnits; xLoadUnits.Content = loadUnits; yLoadUnits.Content = loadUnits; // set node coordinates double xCoord, yCoord; xCoord = (load.Node.Point.X - canvas.OriginOffsetX) / canvas.DpiX * factor * canvas.Scale; yCoord = (canvas.ActualHeight - load.Node.Point.Y - canvas.OriginOffsetY) / canvas.DpiY * factor * canvas.Scale; coords.Content = string.Format("({0}, {1})", Math.Round(xCoord, 2), Math.Round(yCoord, 2)); // set existing load values (if present) MaterialBlock parent = canvas.Substructs.Find(delegate(MaterialBlock mb) { return(mb.Material.Name != "NULL" && mb.PointLoads.Contains(load)); }); isLoadedX.IsEnabled = parent != null && load.IsLoadedX; isLoadedX.IsChecked = xFactor.IsEnabled = parent != null && load.IsActiveX; xFactor.Text = string.Format("{0}", Math.Round(load.XFactor, 3)); xLoad.Text = string.Format("{0}", Math.Round(load.XLoad, 2)); isLoadedY.IsEnabled = parent != null && load.IsLoadedY; isLoadedY.IsChecked = yFactor.IsEnabled = parent != null && load.IsActiveY; yFactor.Text = string.Format("{0}", Math.Round(load.YFactor, 3)); yLoad.Text = string.Format("{0}", Math.Round(load.YLoad, 2)); }
public AddPointLoadDialog(SlopeCanvas canvas, PointLoad load) { InitializeComponent(); this.canvas = canvas; this.load = load; // get units dependent scaling factor and strings double factor; string coordUnits, loadUnits; switch (canvas.Units) { case Units.Metres: factor = 0.0254; coordUnits = "m"; loadUnits = "kN"; break; case Units.Millimetres: factor = 25.4; coordUnits = "mm"; loadUnits = "kN"; break; case Units.Feet: factor = 1.0 / 12.0; coordUnits = "ft"; loadUnits = "lbf"; break; default: factor = 1.0; coordUnits = "in"; loadUnits = "lbf"; break; } // set units labels nodeUnits.Content = coordUnits; xLoadUnits.Content = loadUnits; yLoadUnits.Content = loadUnits; // set node coordinates double xCoord, yCoord; xCoord = (load.Node.Point.X - canvas.OriginOffsetX) / canvas.DpiX * factor * canvas.Scale; yCoord = (canvas.ActualHeight - load.Node.Point.Y - canvas.OriginOffsetY) / canvas.DpiY * factor * canvas.Scale; coords.Content = string.Format("({0}, {1})", Math.Round(xCoord, 2), Math.Round(yCoord, 2)); // set existing load values (if present) isLoadedX.IsChecked = xLoad.IsEnabled = load.IsLoadedX; xLoad.Text = string.Format("{0}", Math.Round(load.XLoad, 2)); isLoadedY.IsChecked = yLoad.IsEnabled = load.IsLoadedY; yLoad.Text = string.Format("{0}", Math.Round(load.YLoad, 2)); }
private List <ILoad> ReadPointLoad(List <Loadcase> loadcases) { int err = 0; List <ILoad> bhLoads = new List <ILoad>(); List <Node> allNodes = ReadNodes(); foreach (Loadcase ldcs in loadcases) { foreach (Node node in allNodes) { int nodeId = GetAdapterId <int>(node); double[] forces = new double[3]; err = St7.St7GetNodeForce3(1, nodeId, GetAdapterId <int>(ldcs), forces); double[] moments = new double[3]; err = St7.St7GetNodeMoment3(1, nodeId, GetAdapterId <int>(ldcs), moments); if (!IsZeroSqLength(forces) || !IsZeroSqLength(moments)) { PointLoad bhLoad = new PointLoad() { Force = new Vector() { X = forces[0], Y = forces[1], Z = forces[2] }, Moment = new Vector() { X = moments[0], Y = moments[1], Z = moments[2] }, Loadcase = ldcs, Objects = new BHoMGroup <Node>() { Elements = { node } } }; bhLoads.Add(bhLoad); } } } return(bhLoads); }
/***************************************************/ /**** Private Methods ****/ /***************************************************/ private List <ILoad> ReadPointLoads(List <string> ids = null) { List <ILoad> pointLoads = new List <ILoad>(); object[] lusasConcentratedLoads = d_LusasData.getAttributes("Concentrated Load"); if (!(lusasConcentratedLoads.Count() == 0)) { List <Node> nodesList = ReadNodes(); Dictionary <string, Node> nodes = nodesList.ToDictionary( x => x.AdapterId <string>(typeof(LusasId))); List <IFLoadcase> allLoadcases = new List <IFLoadcase>(); for (int i = 0; i < lusasConcentratedLoads.Count(); i++) { IFLoading lusasConcentratedLoad = (IFLoading)lusasConcentratedLoads[i]; IEnumerable <IGrouping <string, IFAssignment> > groupedByLoadcases = GetLoadAssignments(lusasConcentratedLoad); foreach (IEnumerable <IFAssignment> groupedAssignment in groupedByLoadcases) { PointLoad pointLoad = Adapters.Lusas.Convert.ToPointLoad( lusasConcentratedLoad, groupedAssignment, nodes ); List <string> analysisName = new List <string> { lusasConcentratedLoad.getAttributeType() }; pointLoad.Tags = new HashSet <string>(analysisName); pointLoads.Add(pointLoad); } } } return(pointLoads); }
/***************************************************/ /**** Public Methods ****/ /***************************************************/ public static PointLoad ToPointLoad( IFLoading lusasPointLoad, IEnumerable <IFAssignment> lusasAssignments, Dictionary <string, Node> nodes) { IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset(); Loadcase loadcase = ToLoadcase(assignedLoadcase); IEnumerable <Node> assignedNodes = GetPointAssignments(lusasAssignments, nodes); Vector forceVector = new Vector { X = lusasPointLoad.getValue("px"), Y = lusasPointLoad.getValue("py"), Z = lusasPointLoad.getValue("pz") }; Vector momentVector = new Vector { X = lusasPointLoad.getValue("mx"), Y = lusasPointLoad.getValue("my"), Z = lusasPointLoad.getValue("mz") }; PointLoad pointLoad = Engine.Structure.Create.PointLoad( loadcase, assignedNodes, forceVector, momentVector, LoadAxis.Global, GetName(lusasPointLoad)); int adapterNameId = lusasPointLoad.getID(); pointLoad.SetAdapterId(typeof(LusasId), adapterNameId); return(pointLoad); }
internal (Vector <double> loadJoints, Matrix <double> loadMagnitude) BuildLoadStructures(IEnumerable <Point3d> joints) { // TODO : It is assumed one load per joint, correct this Vector <double> loadJoints = Vector <double> .Build.Dense(Loads.Count); Matrix <double> loadMagnitude = Matrix <double> .Build.Dense(Loads.Count, 2); for (int i = 0; i < Loads.Count; i++) { PointLoad load = Loads.ElementAt(i); int?loadNode = GetJoint(load.Location, joints); if (!loadNode.HasValue) { throw new InvalidOperationException("Load is not at a joint node"); } loadJoints[i] = loadNode.Value; loadMagnitude[i, 0] = load.XForce; loadMagnitude[i, 1] = load.YForce; } return(loadJoints, loadMagnitude); }
public static LoadType LoadType(this PointLoad load) { return(oM.Structure.Loads.LoadType.PointForce); }
/// <summary> /// /// </summary> /// <param name="app"></param> /// <param name="element"></param> /// <returns></returns> public static Revit.Element CloneElement(Application app, Revit.Element element) { Opening opening = element as Opening; if (opening != null) { return(CloneElement(app, opening)); } BoundaryConditions boundaryConditions = element as BoundaryConditions; if (boundaryConditions != null) { return(CloneElement(app, boundaryConditions)); } AreaLoad areaLoad = element as AreaLoad; if (areaLoad != null) { return(CloneElement(app, areaLoad)); } AreaReinforcement areaReinforcement = element as AreaReinforcement; if (areaReinforcement != null) { return(CloneElement(app, areaReinforcement)); } BeamSystem beamSystem = element as BeamSystem; if (beamSystem != null) { return(CloneElement(app, beamSystem)); } Dimension dimension = element as Dimension; if (dimension != null) { return(CloneElement(app, dimension)); } FamilyInstance familyInstance = element as FamilyInstance; if (familyInstance != null) { return(CloneElement(app, familyInstance)); } Floor floor = element as Floor; if (floor != null) { return(CloneElement(app, floor)); } Grid grid = element as Grid; if (grid != null) { return(CloneElement(app, grid)); } Group group = element as Group; if (group != null) { return(CloneElement(app, group)); } Level level = element as Level; if (floor != null) { return(CloneElement(app, floor)); } LineLoad lineLoad = element as LineLoad; if (lineLoad != null) { return(CloneElement(app, lineLoad)); } LoadCase loadCase = element as LoadCase; if (loadCase != null) { return(CloneElement(app, loadCase)); } LoadCombination loadCombination = element as LoadCombination; if (loadCombination != null) { return(CloneElement(app, loadCombination)); } LoadNature loadNature = element as LoadNature; if (loadNature != null) { return(CloneElement(app, loadNature)); } LoadUsage loadUsage = element as LoadUsage; if (loadUsage != null) { return(CloneElement(app, loadUsage)); } ModelCurve modelCurve = element as ModelCurve; if (modelCurve != null) { return(CloneElement(app, modelCurve)); } PointLoad pointLoad = element as PointLoad; if (pointLoad != null) { return(CloneElement(app, pointLoad)); } Rebar rebar = element as Rebar; if (rebar != null) { return(CloneElement(app, rebar)); } ReferencePlane referencePlane = element as ReferencePlane; if (referencePlane != null) { return(CloneElement(app, referencePlane)); } Room room = element as Room; if (room != null) { return(CloneElement(app, room)); } RoomTag roomTag = element as RoomTag; if (roomTag != null) { return(CloneElement(app, roomTag)); } SketchPlane sketchPlane = element as SketchPlane; if (sketchPlane != null) { return(CloneElement(app, sketchPlane)); } View3D view3D = element as View3D; if (view3D != null) { return(CloneElement(app, view3D)); } ViewDrafting viewDrafting = element as ViewDrafting; if (viewDrafting != null) { return(CloneElement(app, viewDrafting)); } ViewSection viewSection = element as ViewSection; if (viewSection != null) { return(CloneElement(app, viewSection)); } ViewSheet viewSheet = element as ViewSheet; if (viewSheet != null) { return(CloneElement(app, viewSheet)); } Wall wall = element as Wall; if (wall != null) { return(CloneElement(app, wall)); } // this element has not yet been exposed in the Creation Document class //Debug.Assert(false); return(null); }
public static void Edof_BC_fext(out Matrix <double> Edof, out Vector <double> BC, out Vector <double> Fext, out Vector <double> pres, out Matrix <double> bcSprings, List <Bar> bars, List <Node> constraints, List <PointLoad> loads, List <BarPrestressLoad> ploads) { int nEL = bars.Count; int nNode = constraints.Count; List <int> dofs = new List <int>(); List <Point> elPoints = new List <Point>(); for (int i = 0; i < nEL; i++) { Bar aBar = bars[i]; elPoints.Add(aBar.StartNode.Position); elPoints.Add(aBar.EndNode.Position); } double tol = 1e-5; List <Point> cullDup = Geometry.Compute.CullDuplicates(elPoints, tol); Matrix <double> nodeDofs = DenseMatrix.Create(cullDup.Count, 3, 0); for (int i = 0; i < cullDup.Count; i++) { Vector <double> nodeDof = DenseVector.Create(3, 0); nodeDof[0] = 3 * i + 1; nodeDof[1] = 3 * i + 2; nodeDof[2] = 3 * i + 3; nodeDofs.SetRow(i, nodeDof); } // create edof Vector <double> e = DenseVector.Create(nEL, 0); Matrix <double> edof = DenseMatrix.Create(nEL, 6, 0); for (int i = 0; i < nEL; i++) { Bar aBar = bars[i]; int indStart = cullDup.IndexOf(Geometry.Query.ClosestPoint(aBar.StartNode.Position, cullDup)); int indEnd = cullDup.IndexOf(Geometry.Query.ClosestPoint(aBar.EndNode.Position, cullDup)); dofs.Add(indStart); e[i] = i + 1; edof.SetRow(i, nodeDofs.Row(indStart).ToColumnMatrix().Stack(nodeDofs.Row(indEnd).ToColumnMatrix()).Column(0)); //test of indexing string id = "FEMID: " + i.ToString(); bars[i].Tags.Add(id); } Vector <double> nDof = DenseVector.Create(1, 0); Vector <double> temp = DenseVector.Create(2, 0); Matrix <double> bc = DenseMatrix.Create(1, 1, 0); Matrix <double> bc_stiffness = DenseMatrix.Create(1, 2, 0); for (int i = 0; i < constraints.Count; i++) { Node aNode = constraints[i]; int nodeIndex = cullDup.IndexOf(Geometry.Query.ClosestPoint(aNode.Position, cullDup)); // Fixed if (aNode.Support.TranslationX.Equals(BH.oM.Structure.Constraints.DOFType.Fixed)) { nDof[0] = nodeDofs.Row(nodeIndex).At(0); int index = bc.Column(0).Count; bc = bc.InsertRow(index, nDof); } if (aNode.Support.TranslationY.Equals(BH.oM.Structure.Constraints.DOFType.Fixed)) { nDof[0] = nodeDofs.Row(nodeIndex).At(1); int index = bc.Column(0).Count; bc = bc.InsertRow(index, nDof); } if (aNode.Support.TranslationZ.Equals(BH.oM.Structure.Constraints.DOFType.Fixed)) { nDof[0] = nodeDofs.Row(nodeIndex).At(2); int index = bc.Column(0).Count; bc = bc.InsertRow(index, nDof); } // Spring if (aNode.Support.TranslationX.Equals(BH.oM.Structure.Constraints.DOFType.Spring)) { temp[0] = nodeDofs.Row(nodeIndex).At(0); temp[1] = aNode.Support.TranslationalStiffnessX; int index = bc_stiffness.Column(0).Count; bc_stiffness = bc_stiffness.InsertRow(index, temp); } if (aNode.Support.TranslationY.Equals(BH.oM.Structure.Constraints.DOFType.Spring)) { temp[0] = nodeDofs.Row(nodeIndex).At(1); temp[1] = aNode.Support.TranslationalStiffnessY; int index = bc_stiffness.Column(0).Count; bc_stiffness = bc_stiffness.InsertRow(index, temp); } if (aNode.Support.TranslationZ.Equals(BH.oM.Structure.Constraints.DOFType.Spring)) { temp[0] = nodeDofs.Row(nodeIndex).At(2); temp[1] = aNode.Support.TranslationalStiffnessZ; int index = bc_stiffness.Column(0).Count; bc_stiffness = bc_stiffness.InsertRow(index, temp); } } Vector <double> fext = DenseVector.Create(cullDup.Count * 3, 0); for (int i = 0; i < loads.Count; i++) { PointLoad ptLoad = loads[i]; List <Node> loadNodes = ptLoad.Objects.Elements; int a = loadNodes.Count; for (int j = 0; j < a; j++) { BH.oM.Structure.Elements.Node aNode = loadNodes[j]; int nodeIndex = cullDup.IndexOf(Geometry.Query.ClosestPoint(aNode.Position, cullDup)); fext[(int)nodeDofs.Row(nodeIndex).At(0) - 1] = ptLoad.Force.X; fext[(int)nodeDofs.Row(nodeIndex).At(1) - 1] = ptLoad.Force.Y; fext[(int)nodeDofs.Row(nodeIndex).At(2) - 1] = ptLoad.Force.Z; } } pres = DenseVector.Create(edof.RowCount, 0); for (int i = 0; i < ploads.Count; i++) { double Load = ploads[i].Prestress; List <Bar> loadElements = ploads[i].Objects.Elements; for (int j = 0; j < loadElements.Count; j++) { int barIndex = bars.IndexOf(loadElements[j]); pres[barIndex] = Load; } } edof = edof.InsertColumn(0, e); Edof = edof; BC = bc.RemoveRow(0).Column(0); Fext = fext; if (bc_stiffness.RowCount > 1) { bcSprings = bc_stiffness.RemoveRow(0); } else { bcSprings = null; } }
private void Stream( ArrayList data, PointLoad pointload ) { data.Add( new Snoop.Data.ClassSeparator( typeof( PointLoad ) ) ); data.Add( new Snoop.Data.Xyz( "Point", pointload.Point ) ); data.Add( new Snoop.Data.Xyz( "Force", pointload.ForceVector ) ); data.Add( new Snoop.Data.Xyz( "Moment", pointload.MomentVector ) ); }
public void addPload(PointLoad load, Model karambaModel) { _ploads_table.Rows.Add("Point", load.node_ind, load.force, load.moment, load.loadcase); }
/// <summary> /// Convert PointLoad point to Rhino point. /// </summary> internal static Rhino.Geometry.Point3d GetRhinoGeometry(this PointLoad pointLoad) { return(pointLoad.Load.GetFdPoint().ToRhino()); }
public void DeformationTestIsotropicShellInPlane() { var nFaces = 1; var length = 1.0; var xIncMesh = length / nFaces; var limit_dist = xIncMesh / 100.0; var y0 = 0.0; var y1 = 1.0; // create the mesh var mesh = new Mesh3((nFaces + 1) * 2, nFaces); mesh.AddVertex(new Point3(0, y0, 0)); mesh.AddVertex(new Point3(0, y1, 0)); for (var faceInd = 0; faceInd < nFaces; ++faceInd) { mesh.AddVertex(new Point3((faceInd + 1) * xIncMesh, y0, 0)); mesh.AddVertex(new Point3((faceInd + 1) * xIncMesh, y1, 0)); var nV = mesh.Vertices.Count; mesh.AddFace(nV - 4, nV - 3, nV - 1, nV - 2); } // create a shell MeshToShell.solve(new List <Point3>(), new List <Mesh3>() { mesh }, limit_dist, new List <string>(), new List <Color>(), new List <CroSec>(), true, out List <Point3> outPoints, out List <BuilderShell> outBuilderShells, out MessageLogger outLogger); // create two supports var support1 = new Support(new Point3(0, y0, 0), new List <bool>() { true, true, true, true, true, true }, Plane3.Default); var support2 = new Support(new Point3(0, y1, 0), new List <bool>() { true, false, true, true, true, true }, Plane3.Default); // create two point loads var pl1 = new PointLoad(mesh.Vertices.Count - 2, new Vector3(25, 0, 0), new Vector3(), false); var pl2 = new PointLoad(mesh.Vertices.Count - 1, new Vector3(25, 0, 0), new Vector3(), false); // assemble the model var modelBuilder = new ModelBuilder(limit_dist); var model = modelBuilder.build(new List <Point3>(), new List <FemMaterial>(), new List <CroSec>(), new List <Support>() { support1, support2 }, new List <Load>() { pl1, pl2 }, outBuilderShells, new List <ElemSet>(), new List <Joint>(), new MessageLogger() ); ThIAnalyze.solve(model, out var outMaxDisp, out var outG, out var outComp, out var warning, out model); Assert.AreEqual(outMaxDisp[0], 2.4858889456113236E-05, 1E-5); }
/// <summary> /// Gets substruct (material block data) from file /// </summary> public void LoadSubstructData() { if (!File.Exists(FilePath)) { MessageBox.Show("Could not find input data file.", "Error"); return; } // get canvas dimensions/properties double originX = OriginOffsetX, originY = OriginOffsetY, scale = Scale, yHeight = ActualHeight; Units units = Units; // get units dependent scaling factor double factor; switch (units) { case Units.Metres: factor = 0.0254; break; case Units.Millimetres: factor = 25.4; break; case Units.Feet: factor = 1.0 / 12.0; break; default: factor = 1.0; break; } // Load material blocks from source canvas substructs = new List <MaterialBlock>(); using (TextReader tr = new StreamReader(FilePath)) { // advance to material block data while (!tr.ReadLine().Contains("MATERIAL BLOCK DATA")) { ; } tr.ReadLine(); tr.ReadLine(); int numMaterialBlocks = int.Parse(tr.ReadLine().Split('=')[1]); tr.ReadLine(); if (numMaterialBlocks > 0) { MaterialBlock block; MaterialType mtl; DrawingPoint p1, p2; LineConstraint newLC, existingLC; LineLoad newLL, existingLL; PointLoad newPL, existingPL; Point[] materialBoundPoints; bool[] isFixedX; bool[] isFixedY; bool[] isPrintPoint; string materialName; int numMaterialBoundPoints, numLineConstraints, numLineLoads, numPointLoads; double xCoord, yCoord; string[] coords, lineConstraint, lineLoad, pointLoad; for (int i = 0; i < numMaterialBlocks; i++) { tr.ReadLine(); materialName = tr.ReadLine().Split(new char[] { '\"' }, StringSplitOptions.RemoveEmptyEntries)[1]; mtl = materialTypes.Find(delegate(MaterialType mt) { return(mt.Name == materialName); }); numMaterialBoundPoints = int.Parse(tr.ReadLine().Split('=')[1]); materialBoundPoints = new Point[numMaterialBoundPoints]; isFixedX = new bool[numMaterialBoundPoints]; isFixedY = new bool[numMaterialBoundPoints]; isPrintPoint = new bool[numMaterialBoundPoints]; for (int j = 0; j < numMaterialBoundPoints; j++) { coords = tr.ReadLine().Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); xCoord = double.Parse(coords[0]); yCoord = double.Parse(coords[1]); materialBoundPoints[j].X = xCoord / (factor * Scale) * dpiX + OriginOffsetX; materialBoundPoints[j].Y = ActualHeight - (yCoord / (factor * Scale) * dpiY + OriginOffsetY); isFixedX[j] = coords[2] == bool.TrueString; isFixedY[j] = coords[3] == bool.TrueString; isPrintPoint[j] = coords[4] == bool.TrueString; } block = new MaterialBlock(this, mtl, materialBoundPoints); for (int j = 0; j < numMaterialBoundPoints; j++) { block.BoundaryPoints[j].IsFixedX = isFixedX[j]; block.BoundaryPoints[j].IsFixedY = isFixedY[j]; block.BoundaryPoints[j].IsPrintPoint = isPrintPoint[j]; } substructs.Add(block); numLineConstraints = int.Parse(tr.ReadLine().Split('=')[1]); for (int j = 0; j < numLineConstraints; j++) { lineConstraint = tr.ReadLine().Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); p1 = block.BoundaryPoints[int.Parse(lineConstraint[0])]; p2 = block.BoundaryPoints[int.Parse(lineConstraint[1])]; existingLC = null; foreach (MaterialBlock mb in substructs) { existingLC = mb.LineConstraints.Find(delegate(LineConstraint lc) { return(lc.Nodes.Contains(p1) && lc.Nodes.Contains(p2)); }); if (existingLC != null) { break; } } if (existingLC == null) { newLC = new LineConstraint(this, p1, p2, //newMaterialBlock.BoundaryPoints[int.Parse( lineConstraint[0] )] , //newMaterialBlock.BoundaryPoints[int.Parse( lineConstraint[1] )] , lineConstraint[2] == bool.TrueString, lineConstraint[3] == bool.TrueString); } else { block.LineConstraints.Add(existingLC); } //newLC = new LineConstraint( this , // block.BoundaryPoints[int.Parse( lineConstraint[0] )] , // block.BoundaryPoints[int.Parse( lineConstraint[1] )] , // lineConstraint[2] == bool.TrueString , // lineConstraint[3] == bool.TrueString ); //existingLC = null; //foreach ( MaterialBlock mb in substructs ) //{ // existingLC = mb.LineConstraints.Find( // delegate( LineConstraint lc ) // { // return lc.Nodes.Contains( newLC.Nodes[0] ) && lc.Nodes.Contains( newLC.Nodes[1] ); // } ); // if ( existingLC != null ) break; //} //if ( existingLC != null ) //{ // if ( !block.LineConstraints.Contains( existingLC ) ) // block.LineConstraints.Add( existingLC ); //} //else block.LineConstraints.Add( newLC ); } numLineLoads = int.Parse(tr.ReadLine().Split('=')[1]); for (int j = 0; j < numLineLoads; j++) { lineLoad = tr.ReadLine().Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); p1 = block.BoundaryPoints[int.Parse(lineLoad[0])]; p2 = block.BoundaryPoints[int.Parse(lineLoad[1])]; existingLL = null; foreach (MaterialBlock mb in substructs) { existingLL = mb.LineLoads.Find(delegate(LineLoad ll) { return(ll.Nodes.Contains(p1) && ll.Nodes.Contains(p2)); }); if (existingLL != null) { break; } } if (existingLL == null) { newLL = new LineLoad(this, p1, p2, //newMaterialBlock.BoundaryPoints[int.Parse( lineConstraint[0] )] , //newMaterialBlock.BoundaryPoints[int.Parse( lineConstraint[1] )] , lineLoad[2] == bool.TrueString, double.Parse(lineLoad[3]), double.Parse(lineLoad[4]), lineLoad[5] == bool.TrueString, double.Parse(lineLoad[6]), double.Parse(lineLoad[7])); } else { block.LineLoads.Add(existingLL); } //block.LineLoads.Add( new LineLoad( this , // block.BoundaryPoints[int.Parse( lineLoad[0] )] , // block.BoundaryPoints[int.Parse( lineLoad[1] )] , // lineLoad[2] == bool.TrueString , double.Parse( lineLoad[3] ) , double.Parse( lineLoad[4] ) , // lineLoad[5] == bool.TrueString , double.Parse( lineLoad[6] ) , double.Parse( lineLoad[7] ) ) ); } numPointLoads = int.Parse(tr.ReadLine().Split('=')[1]); for (int j = 0; j < numPointLoads; j++) { pointLoad = tr.ReadLine().Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); p1 = block.BoundaryPoints[int.Parse(pointLoad[0])]; existingPL = null; foreach (MaterialBlock mb in substructs) { existingPL = mb.PointLoads.Find(delegate(PointLoad pl) { return(pl.Node == p1); }); if (existingPL != null) { break; } } if (existingPL == null) { newPL = new PointLoad(this, p1, //newMaterialBlock.BoundaryPoints[int.Parse( lineConstraint[0] )] , //newMaterialBlock.BoundaryPoints[int.Parse( lineConstraint[1] )] , pointLoad[1] == bool.TrueString, double.Parse(pointLoad[2]), pointLoad[3] == bool.TrueString, double.Parse(pointLoad[4])); } else { block.PointLoads.Add(existingPL); } //block.PointLoads.Add( new PointLoad( this , // block.BoundaryPoints[int.Parse( pointLoad[0] )] , // pointLoad[1] == bool.TrueString , double.Parse( pointLoad[2] ) , // pointLoad[3] == bool.TrueString , double.Parse( pointLoad[4] ) ) ); } tr.ReadLine(); } } } // Set selected analysis phase to first (if present) if (source.AnalysisPhases.Count > 1) { ComboBox phaseList = (ComboBox)((Grid)((GroupBox)((Grid)((ScrollViewer)((Grid)this.Parent).Children[2]).Content).Children[1]).Content).Children[1]; AnalysisPhase initial = source.AnalysisPhases[1]; phaseList.SelectedItem = initial; } }