/***************************************************/ public static List <ICurve> Visualize(this BarPointLoad barPointForce, double scaleFactor = 1.0, bool displayForces = true, bool displayMoments = true, bool asResultants = true) { List <ICurve> arrows = new List <ICurve>(); Vector forceVec = barPointForce.Force * scaleFactor; Vector momentVec = barPointForce.Moment * scaleFactor; foreach (Bar bar in barPointForce.Objects.Elements) { Cartesian system; Vector[] loads = BarForceVectors(bar, forceVec, momentVec, barPointForce.Axis, barPointForce.Projected, out system); Point point = bar.StartNode.Position(); Vector tan = bar.Tangent(true); point += tan * barPointForce.DistanceFromA; if (displayForces) { arrows.AddRange(Arrows(point, loads[0], true, asResultants, system)); } if (displayMoments) { arrows.AddRange(Arrows(point, loads[1], false, asResultants, system)); } } return(arrows); }
/***************************************************/ private bool CreateLoad(BarPointLoad bhLoad) { List <Bar> bars = bhLoad.Objects.Elements.ToList(); string loadPat = GetAdapterId <string>(bhLoad.Loadcase); int loadType = 0; int[] dirs = null; double[] forceVals = null; double[] momentVals = null; double dist = bhLoad.DistanceFromA; bool relDist = false; // BarPointLoad is defined as absolute distance from i (A) end of bar. // Determine coordinate system (local vs global) and set directions vector for CSI protocol switch (bhLoad.Axis) { case LoadAxis.Global: dirs = new int[] { 4, 5, 6 }; forceVals = bhLoad.Force.ToDoubleArray(); momentVals = bhLoad.Moment.ToDoubleArray(); break; case LoadAxis.Local: dirs = new int[] { 1, 2, 3 }; forceVals = bhLoad.Force.BarLocalAxisToCSI().ToDoubleArray(); momentVals = bhLoad.Moment.BarLocalAxisToCSI().ToDoubleArray(); break; } // Loop through bars and set point loads string cSys = bhLoad.Axis.ToCSI(); bool replace = SAPPushConfig.ReplaceLoads; eItemType type = eItemType.Objects; foreach (Bar bar in bars) { string barName = GetAdapterId <string>(bar); bool replaceNow = replace; for (int i = 0; i < dirs.Count(); i++) { loadType = 1; // handle forces first if (m_model.FrameObj.SetLoadPoint(barName, loadPat, loadType, dirs[i], dist, forceVals[i], cSys, relDist, replaceNow, type) != 0) { CreateElementError("BarPointLoad-Force", bar.Name + dirs[i]); } replaceNow = false; loadType = 2; // handle moments second if (m_model.FrameObj.SetLoadPoint(barName, loadPat, loadType, dirs[i], dist, momentVals[i], cSys, relDist, replaceNow, type) != 0) { CreateElementError("BarPointLoad-Moment", bar.Name + dirs[i]); } } } SetAdapterId(bhLoad, null); return(true); }
/***************************************************/ public void SetLoad(BarPointLoad barPointLoad, bool replace) { string axis; int shift; GetDirectionData(barPointLoad, out axis, out shift); foreach (Bar bar in barPointLoad.Objects.Elements) { bool stepReplace = replace; string caseName = GetAdapterId <string>(barPointLoad.Loadcase); string barName = GetAdapterId <string>(bar); for (int direction = 1; direction <= 3; direction++) { int ret = 1; double val = direction == 1 ? barPointLoad.Force.X : barPointLoad.Axis == LoadAxis.Global ? direction == 2 ? barPointLoad.Force.Y : barPointLoad.Force.Z : direction == 2 ? barPointLoad.Force.Z : -barPointLoad.Force.Y; //note: etabs acts different then stated in API documentstion if (val != 0) { ret = m_model.FrameObj.SetLoadPoint(barName, caseName, 1, direction + shift, barPointLoad.DistanceFromA, val, axis, false, stepReplace); stepReplace = false; } } // Moment for (int direction = 1; direction <= 3; direction++) { int ret = 1; double val = direction == 1 ? barPointLoad.Moment.X : barPointLoad.Axis == LoadAxis.Global ? direction == 2 ? barPointLoad.Moment.Y : barPointLoad.Moment.Z : direction == 2 ? barPointLoad.Moment.Z : -barPointLoad.Moment.Y; //note: etabs acts different then stated in API documentstion if (val != 0) { ret = m_model.FrameObj.SetLoadPoint(barName, caseName, 2, direction + shift, barPointLoad.DistanceFromA, val, axis, false, stepReplace); stepReplace = false; } } } }
/***************************************************/ /**** Private Methods ****/ /***************************************************/ private List <ILoad> ReadBarPointLoads(List <string> ids = null) { List <ILoad> barPointLoads = new List <ILoad>(); object[] lusasInternalBeamPointLoads = d_LusasData.getAttributes("Beam Point Load"); if (lusasInternalBeamPointLoads.Count() != 0) { List <Bar> barsList = ReadBars(); Dictionary <string, Bar> bars = barsList.ToDictionary( x => x.AdapterId <string>(typeof(LusasId))); List <IFLoadcase> allLoadcases = new List <IFLoadcase>(); for (int i = 0; i < lusasInternalBeamPointLoads.Count(); i++) { IFLoading lusasInternalBeamPointLoad = (IFLoading)lusasInternalBeamPointLoads[i]; IEnumerable <IGrouping <string, IFAssignment> > groupedByLoadcases = GetLoadAssignments(lusasInternalBeamPointLoad); foreach (IEnumerable <IFAssignment> groupedAssignment in groupedByLoadcases) { BarPointLoad barPointLoad = Adapters.Lusas.Convert.ToBarPointLoad( lusasInternalBeamPointLoad, groupedAssignment, bars); List <string> analysisName = new List <string> { lusasInternalBeamPointLoad.getAttributeType() }; barPointLoad.Tags = new HashSet <string>(analysisName); barPointLoads.Add(barPointLoad); } } } return(barPointLoads); }
/***************************************************/ /**** Private Methods ****/ /***************************************************/ private IFLoadingBeamPoint CreateBarPointLoad(BarPointLoad barPointLoad, object[] lusasLines) { IFLoadingBeamPoint lusasBarPointLoad; IFLoadcase assignedLoadcase = (IFLoadcase)d_LusasData.getLoadset(barPointLoad.Loadcase.AdapterId <int>(typeof(LusasId))); if (d_LusasData.existsAttribute("Loading", barPointLoad.Name)) { lusasBarPointLoad = (IFLoadingBeamPoint)d_LusasData.getAttribute("Loading", barPointLoad.Name); } else { lusasBarPointLoad = d_LusasData.createLoadingBeamPoint(barPointLoad.Name); if (barPointLoad.Axis.ToString() == "Global") { lusasBarPointLoad.setBeamPoint("parametric", "global", "beam"); } else { lusasBarPointLoad.setBeamPoint("parametric", "local", "beam"); } lusasBarPointLoad.addRow( barPointLoad.DistanceFromA, barPointLoad.Force.X, barPointLoad.Force.Y, barPointLoad.Force.Z, barPointLoad.Moment.X, barPointLoad.Moment.Y, barPointLoad.Moment.Z); } IFAssignment lusasAssignment = m_LusasApplication.assignment(); lusasAssignment.setLoadset(assignedLoadcase); lusasBarPointLoad.assignTo(lusasLines, lusasAssignment); int adapterIdName = lusasBarPointLoad.getID(); barPointLoad.SetAdapterId(typeof(LusasId), adapterIdName); return(lusasBarPointLoad); }
public static LoadType LoadType(this BarPointLoad load) { return(oM.Structure.Loads.LoadType.BarPointLoad); }
/***************************************************/ private List <ILoad> ReadBarPointLoad(List <Loadcase> loadcases) { List <ILoad> bhLoads = new List <ILoad>(); Dictionary <string, Bar> bhomBars = ReadBar().ToDictionary(x => GetAdapterId <string>(x)); string[] names = null; string[] loadcase = null; string[] CSys = null; int[] myType = null; int[] dir = null; int nameCount = 0; double[] relDist = null; double[] dist = null; double[] value = null; if (m_model.FrameObj.GetLoadPoint("All", ref nameCount, ref names, ref loadcase, ref myType, ref CSys, ref dir, ref relDist, ref dist, ref value, eItemType.Group) != 0) { return(bhLoads); } for (int i = 0; i < nameCount; i++) { Loadcase bhLoadcase = loadcases.FirstOrDefault(x => x.Name == loadcase[i]); if (bhLoadcase == null) { continue; } Vector force = Direction(dir[i], value[i]); BHoMGroup <Bar> barObjects = new BHoMGroup <Bar>() { Elements = { bhomBars[names[i]] } }; BarPointLoad bhBarPointLoad = new BarPointLoad() { DistanceFromA = dist[i], Loadcase = bhLoadcase, Objects = barObjects }; switch (myType[i]) { case 1: bhBarPointLoad.Force = force; break; case 2: bhBarPointLoad.Moment = force; break; default: BH.Engine.Base.Compute.RecordWarning("Could not create the load. It's not 'MyType'. MyType = " + myType[i].ToString()); continue; } SetDirection(bhBarPointLoad, dir[i], CSys[i]); bhLoads.Add(bhBarPointLoad); } return(bhLoads); }
/***************************************************/ /**** Private methods ****/ /***************************************************/ private List <ILoad> ReadLoads(List <string> ids = null) { List <ILoad> loadList = new List <ILoad>(); if (ids == null) { List <rf.LoadCase> rfLoadcases = model.GetLoads().GetLoadCases().ToList(); rf.ILoads l = model.GetLoads(); int lcCount = l.GetLoadCaseCount(); Dictionary <int, Loadcase> bhLoadcaseDict = new Dictionary <int, Loadcase>(); bhLoadcaseDict = ReadLoadcases().Distinct().ToDictionary(x => x.Number, x => x); Dictionary <string, Bar> bhBarDict = new Dictionary <string, Bar>(); bool barsRead = false; for (int i = 0; i < lcCount; i++) { rf.LoadCase rfLoadcase = l.GetLoadCase(i, rf.ItemAt.AtIndex).GetData(); Loadcase bhLoadcase; bhLoadcase = bhLoadcaseDict[rfLoadcase.Loading.No]; rf.MemberLoad[] rfMemberLoads = l.GetLoadCase(i, rf.ItemAt.AtIndex).GetMemberLoads(); if (rfMemberLoads.Length > 0) { if (!barsRead) { bhBarDict = ReadBars().ToDictionary(x => GetAdapterId(x).ToString(), x => x); barsRead = true; } foreach (rf.MemberLoad rfLoad in rfMemberLoads) { List <string> barIds = BH.Engine.Adapters.RFEM.Compute.GetIdListFromString(rfLoad.ObjectList); oM.Base.BHoMGroup <Bar> barGroup = new oM.Base.BHoMGroup <Bar>(); barGroup.Elements.AddRange(barIds.Where(k => bhBarDict.ContainsKey(k)).Select(k => bhBarDict[k])); if (rfLoad.Distribution == rf.LoadDistributionType.UniformType) { BarUniformlyDistributedLoad barUniformLoad = rfLoad.FromRFEM(bhLoadcase, barGroup); loadList.Add(barUniformLoad); } else if (rfLoad.Distribution == rf.LoadDistributionType.ConcentratedType) { BarPointLoad barPointLoad = new BarPointLoad(); //... } else { Engine.Base.Compute.RecordWarning("Load distribution of type: " + rfLoad.Distribution.ToString() + " is not supported!"); } } } } } else { foreach (string id in ids) { //loadList.Add(); } } return(loadList); }
private List <ILoad> ReadBarPointLoad(List <Loadcase> loadcases) { int err = 0; Dictionary <int, Loadcase> lcDict = loadcases.ToDictionary(x => GetAdapterId <int>(x)); List <ILoad> bhLoads = new List <ILoad>(); List <Bar> allBars = ReadBars(); foreach (Bar bar in allBars) { double length = BH.Engine.Geometry.Query.Length(BH.Engine.Structure.Query.Centreline(bar)); int barId = GetAdapterId <int>(bar); // ***************** try to get point forces first ************************ // ****************************** global ********************************** int globalPointForceCount = 0; err = St7.St7GetEntityAttributeSequenceCount(1, St7.tyBEAM, barId, St7.aoBeamCFG, ref globalPointForceCount); if (globalPointForceCount > 0) { // getting load IDs int[] sequenceNumbers = new int[globalPointForceCount * 4]; err = St7.St7GetEntityAttributeSequence(1, St7.tyBEAM, barId, St7.aoBeamCFG, globalPointForceCount, sequenceNumbers); for (int i = 0; i < globalPointForceCount; i++) { int loadCaseNum = sequenceNumbers[4 * i + St7.ipAttrCase]; int loadID = sequenceNumbers[4 * i + St7.ipAttrID]; double[] forcesG = new double[4]; err = St7.St7GetBeamPointForceGlobal4ID(1, barId, loadCaseNum, loadID, forcesG); if (!IsZeroSqLength(forcesG)) { BarPointLoad bhLoad = new BarPointLoad() { DistanceFromA = length * forcesG[3], Force = new Vector() { X = forcesG[0], Y = forcesG[1], Z = forcesG[2] }, Loadcase = lcDict[loadCaseNum], Projected = false, Axis = LoadAxis.Global, Objects = new BHoMGroup <Bar>() { Elements = { bar } } }; bhLoads.Add(bhLoad); } } } int globalPointMomentCount = 0; err = St7.St7GetEntityAttributeSequenceCount(1, St7.tyBEAM, barId, St7.aoBeamCMG, ref globalPointMomentCount); if (globalPointMomentCount > 0) { // getting load IDs int[] sequenceNumbers = new int[globalPointMomentCount * 4]; err = St7.St7GetEntityAttributeSequence(1, St7.tyBEAM, barId, St7.aoBeamCMG, globalPointMomentCount, sequenceNumbers); for (int i = 0; i < globalPointMomentCount; i++) { int loadCaseNum = sequenceNumbers[4 * i + St7.ipAttrCase]; int loadID = sequenceNumbers[4 * i + St7.ipAttrID]; double[] momentsG = new double[4]; err = St7.St7GetBeamPointMomentGlobal4ID(1, barId, loadCaseNum, loadID, momentsG); if (!IsZeroSqLength(momentsG)) { BarPointLoad bhLoad = new BarPointLoad() { DistanceFromA = length * momentsG[3], Moment = new Vector() { X = momentsG[0], Y = momentsG[1], Z = momentsG[2] }, Loadcase = lcDict[loadCaseNum], Projected = false, Axis = LoadAxis.Global, Objects = new BHoMGroup <Bar>() { Elements = { bar } } }; bhLoads.Add(bhLoad); } } } // ****************************** principal ********************************** int principalPointForceCount = 0; err = St7.St7GetEntityAttributeSequenceCount(1, St7.tyBEAM, barId, St7.aoBeamCFL, ref principalPointForceCount); if (principalPointForceCount > 0) { // getting load IDs int[] sequenceNumbers = new int[principalPointForceCount * 4]; err = St7.St7GetEntityAttributeSequence(1, St7.tyBEAM, barId, St7.aoBeamCFL, principalPointForceCount, sequenceNumbers); for (int i = 0; i < principalPointForceCount; i++) { int loadCaseNum = sequenceNumbers[4 * i + St7.ipAttrCase]; int loadID = sequenceNumbers[4 * i + St7.ipAttrID]; double[] forcesP = new double[4]; err = St7.St7GetBeamPointForcePrincipal4ID(1, barId, loadCaseNum, loadID, forcesP); if (!IsZeroSqLength(forcesP)) { BarPointLoad bhLoad = new BarPointLoad() { DistanceFromA = length * forcesP[3], //Force = BH.Engine.Geometry.Modify.Transform(new Vector() { X = forcesP[0], Y = forcesP[1], Z = forcesP[2] }, transformMatrix), Force = new Vector() { X = forcesP[0], Y = forcesP[1], Z = forcesP[2] }, Loadcase = lcDict[loadCaseNum], Projected = false, Axis = LoadAxis.Local, Objects = new BHoMGroup <Bar>() { Elements = { bar } } }; bhLoads.Add(bhLoad); } } } int principalPointMomentCount = 0; err = St7.St7GetEntityAttributeSequenceCount(1, St7.tyBEAM, barId, St7.aoBeamCML, ref principalPointMomentCount); if (principalPointMomentCount > 0) { // getting load IDs int[] sequenceNumbers = new int[principalPointMomentCount * 4]; err = St7.St7GetEntityAttributeSequence(1, St7.tyBEAM, barId, St7.aoBeamCML, principalPointMomentCount, sequenceNumbers); for (int i = 0; i < principalPointMomentCount; i++) { int loadCaseNum = sequenceNumbers[4 * i + St7.ipAttrCase]; int loadID = sequenceNumbers[4 * i + St7.ipAttrID]; double[] momentsP = new double[4]; err = St7.St7GetBeamPointMomentPrincipal4ID(1, barId, loadCaseNum, loadID, momentsP); if (!IsZeroSqLength(momentsP)) { BarPointLoad bhLoad = new BarPointLoad() { DistanceFromA = length * momentsP[3], //Moment = BH.Engine.Geometry.Modify.Transform(new Vector() { X = momentsP[0], Y = momentsP[1], Z = momentsP[2] }, transformMatrix), Moment = new Vector() { X = momentsP[0], Y = momentsP[1], Z = momentsP[2] }, Projected = false, Axis = LoadAxis.Local, Loadcase = lcDict[loadCaseNum], Objects = new BHoMGroup <Bar>() { Elements = { bar } } }; bhLoads.Add(bhLoad); } } } } return(bhLoads); }
/***************************************************/ /**** Private methods ****/ /***************************************************/ private bool CreateObject(BarPointLoad barPointLoad) { int err = 0; int uID = 1; int loadCaseId = GetAdapterId <int>(barPointLoad.Loadcase); // *************************** GLOBAL *************************** if (barPointLoad.Axis == LoadAxis.Global) { foreach (Bar bar in barPointLoad.Objects.Elements) { double length = BH.Engine.Geometry.Query.Length(BH.Engine.Structure.Query.Centreline(bar)); int barId = GetAdapterId <int>(bar); // creating global Point Forces if (BH.Engine.Geometry.Query.Length(barPointLoad.Force) > 0) { // get number of global point forces at the beam int globalPointForceCount = 0; err = St7.St7GetEntityAttributeSequenceCount(uID, St7.tyBEAM, barId, St7.aoBeamCFG, ref globalPointForceCount); if (!St7ErrorCustom(err, "Couldn't get a number of global point beam loads for a loadcase " + loadCaseId + " beam " + barId)) { return(false); } double[] forces = new double[4]; forces[0] = barPointLoad.Force.X; forces[1] = barPointLoad.Force.Y; forces[2] = barPointLoad.Force.Z; forces[3] = barPointLoad.DistanceFromA / length; err = St7.St7SetBeamPointForceGlobal4ID(uID, barId, loadCaseId, globalPointForceCount + 1, forces); if (!St7ErrorCustom(err, "Couldn't set global point beam loads for a loadcase " + loadCaseId + " beam " + barId)) { return(false); } } // creating global Point Moments if (BH.Engine.Geometry.Query.Length(barPointLoad.Moment) > 0) { // get number of global point moments at the beam int globalPointMomentCount = 0; err = St7.St7GetEntityAttributeSequenceCount(uID, St7.tyBEAM, barId, St7.aoBeamCMG, ref globalPointMomentCount); if (!St7ErrorCustom(err, "Couldn't get a number of global point beam moments for a loadcase " + loadCaseId + " beam " + barId)) { return(false); } double[] moments = new double[4]; moments[0] = barPointLoad.Moment.X; moments[1] = barPointLoad.Moment.Y; moments[2] = barPointLoad.Moment.Z; moments[3] = barPointLoad.DistanceFromA / length; err = St7.St7SetBeamPointMomentGlobal4ID(uID, barId, loadCaseId, globalPointMomentCount + 1, moments); if (!St7ErrorCustom(err, "Couldn't set global point beam moments for a loadcase " + loadCaseId + " beam " + barId)) { return(false); } } } } // *************************** LOCAL **************************** if (barPointLoad.Axis == LoadAxis.Local) { foreach (Bar bar in barPointLoad.Objects.Elements) { double length = BH.Engine.Geometry.Query.Length(BH.Engine.Structure.Query.Centreline(bar)); int barId = GetAdapterId <int>(bar); if (BH.Engine.Geometry.Query.Length(barPointLoad.Force) > 0) { // get number of local point forces at the beam int localPointForceCount = 0; err = St7.St7GetEntityAttributeSequenceCount(uID, St7.tyBEAM, barId, St7.aoBeamCFL, ref localPointForceCount); if (!St7ErrorCustom(err, "Couldn't get a number of local point beam loads for a loadcase " + loadCaseId + " beam " + barId)) { return(false); } double[] forces = new double[4]; forces[0] = barPointLoad.Force.X; forces[1] = barPointLoad.Force.Y; forces[2] = barPointLoad.Force.Z; forces[3] = barPointLoad.DistanceFromA / length; err = St7.St7SetBeamPointForcePrincipal4ID(uID, barId, loadCaseId, localPointForceCount + 1, forces); if (!St7ErrorCustom(err, "Couldn't set local point beam loads for a loadcase " + loadCaseId + " beam " + barId)) { return(false); } } // creating global Point Moments if (BH.Engine.Geometry.Query.Length(barPointLoad.Moment) > 0) { // get number of local point moments at the beam int localPointMomentCount = 0; err = St7.St7GetEntityAttributeSequenceCount(uID, St7.tyBEAM, barId, St7.aoBeamCML, ref localPointMomentCount); if (!St7ErrorCustom(err, "Couldn't get a number of local point beam moments for a loadcase " + loadCaseId + " beam " + barId)) { return(false); } double[] moments = new double[4]; moments[0] = barPointLoad.Moment.X; moments[1] = barPointLoad.Moment.Y; moments[2] = barPointLoad.Moment.Z; moments[3] = barPointLoad.DistanceFromA / length; err = St7.St7SetBeamPointMomentPrincipal4ID(uID, barId, loadCaseId, localPointMomentCount + 1, moments); if (!St7ErrorCustom(err, "Couldn't set local point beam moments for a loadcase " + loadCaseId + " beam " + barId)) { return(false); } } } } return(true); }