/***************************************************/ private static Dataset SetGraphDataSet(Graph graph, IView view) { if (view is DependencyChart) { DependencyChart chart = view as DependencyChart; string groupPropertName = chart.Boxes.Group; foreach (IBHoMObject entity in graph.Entities()) { if (chart.Boxes.GroupsToIgnore.Contains(entity.PropertyValue(groupPropertName))) { graph.RemoveEntity(entity); } } } BHoMGroup <IBHoMObject> entities = new BHoMGroup <IBHoMObject>(); entities.Elements = graph.Entities(); entities.Name = "Entities"; BHoMGroup <IBHoMObject> relations = new BHoMGroup <IBHoMObject>(); relations.Elements = graph.Relations.Cast <IBHoMObject>().ToList(); relations.Name = "Relations"; Dataset graphData = new Dataset(); graphData.Data = new List <IBHoMObject>(); graphData.Data.Add(entities); graphData.Data.Add(relations); return(graphData); }
public static List <BarVaryingDistributedLoad> BarVaryingDistributedLoadDistanceBothEnds(Loadcase loadcase, BHoMGroup <Bar> group, bool relativePositions, double startToStartDistance = 0, Vector forceAtStart = null, Vector momentAtStart = null, double endToEndDistance = 0, Vector forceAtEnd = null, Vector momentAtEnd = null, LoadAxis axis = LoadAxis.Global, bool projected = false, string name = "", double groupingTolerance = Tolerance.Distance) { if ((forceAtStart == null || forceAtEnd == null) && (momentAtStart == null || momentAtEnd == null)) { Reflection.Compute.RecordError("BarVaryingDistributedLoad requires at least the force at start and end or the moment at start and end to be defined."); return(null); } Dictionary <double, List <Bar> > barGroups = GroupBarsByLength(group.Elements, groupingTolerance); List <BarVaryingDistributedLoad> loads = new List <BarVaryingDistributedLoad>(); foreach (KeyValuePair <double, List <Bar> > kvp in barGroups) { BHoMGroup <Bar> newGroup = new BHoMGroup <Bar> { Elements = kvp.Value, Name = group.Name }; double endPosition; if (relativePositions) { endPosition = 1 - endToEndDistance; } else { endPosition = kvp.Key - endToEndDistance; } loads.Add(BarVaryingDistributedLoad(loadcase, newGroup, startToStartDistance, forceAtStart, momentAtStart, endPosition, forceAtEnd, momentAtEnd, relativePositions, axis, projected, name)); } return(loads.Where(x => x != null).ToList()); }
public static BarDifferentialTemperatureLoad BarDifferentialTemperatureLoad(Loadcase loadcase, List <double> positions, List <double> temperatures, DifferentialTemperatureLoadDirection localLoadDirection, IEnumerable <Bar> objects, string name = "") { if (loadcase.IsNull() || positions.IsNullOrEmpty() || temperatures.IsNullOrEmpty()) { return(null); } //Checks for positions and profiles if (positions.Count != temperatures.Count) { Reflection.Compute.RecordError("Number of positions and temperatures provided are not equal"); return(null); } else if (positions.Exists((double d) => { return(d > 1); }) || positions.Exists((double d) => { return(d < 0); })) { Reflection.Compute.RecordError("Positions must exist between 0 and 1 (inclusive)"); return(null); } // Check that top and bottom positions are included if (!(positions.Contains(0) && positions.Contains(1))) { Reflection.Compute.RecordError("Positions must inlude the bottom (0) and top (1) position."); return(null); } if (positions.Zip(positions.Skip(1), (a, b) => new { a, b }).Any(p => p.a > p.b)) { Reflection.Compute.RecordError("Positions must be sorted in ascending order."); return(null); } //Create ditionary for TaperedProfile Dictionary <Double, Double> temperatureProfile = positions.Zip(temperatures, (z, t) => new { z, t }) .ToDictionary(x => x.z, x => x.t); BHoMGroup <Bar> group = new BHoMGroup <Bar>(); if (objects == null) { group = null; } else { group.Elements = objects.ToList(); } return(new BarDifferentialTemperatureLoad { Loadcase = loadcase, TemperatureProfile = temperatureProfile, LoadDirection = localLoadDirection, Objects = group, Name = name }); }
/***************************************************/ public static GravityLoad GravityLoad(Loadcase loadcase, Vector direction, BHoMGroup <BHoMObject> group, string name = "") { return(new GravityLoad { Loadcase = loadcase, GravityDirection = direction, Objects = group, Name = name }); }
/***************************************************/ private List <ILoad> ReadAreaLoad(List <Loadcase> loadcases) { List <ILoad> bhLoads = new List <ILoad>(); Dictionary <string, Panel> bhomPanels = ReadPanel().ToDictionary(x => GetAdapterId <string>(x)); string[] names = null; string[] loadcase = null; string[] CSys = null; int[] dir = null; int nameCount = 0; double[] f = null; if (m_model.AreaObj.GetLoadUniform("All", ref nameCount, ref names, ref loadcase, ref CSys, ref dir, ref f, 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; } BHoMGroup <IAreaElement> panelObjects = new BHoMGroup <IAreaElement>() { Elements = { bhomPanels[names[i]] } }; Vector pressure = Direction(dir[i], f[i]); if (CSys[i] == "Local") { double temp = -pressure.Y; pressure.Y = pressure.Z; pressure.Z = temp; } AreaUniformlyDistributedLoad bhAreaUniLoad = new AreaUniformlyDistributedLoad() { Pressure = pressure, Loadcase = bhLoadcase, Objects = panelObjects }; SetDirection(bhAreaUniLoad, dir[i], CSys[i]); bhLoads.Add(bhAreaUniLoad); } return(bhLoads); }
private List <ILoad> ReadAreaLoad(List <Loadcase> loadcases) { int uID = 1; int err = 0; List <ILoad> bhLoads = new List <ILoad>(); List <Panel> bhPanels = ReadPanel(); Vector localPressure = new Vector(); Vector globalPressure = new Vector(); foreach (Loadcase ldcs in loadcases) { int ldcsId = GetAdapterId <int>(ldcs); foreach (Panel panel in bhPanels) { BHoMGroup <IAreaElement> panelObjects = new BHoMGroup <IAreaElement>() { Elements = { panel } }; int panelId = GetAdapterId <int>(panel); // local pressures double[] normalPressures = new double[2]; err = St7.St7GetPlateNormalPressure2(uID, panelId, ldcsId, normalPressures); double[] shearPressures = new double[2]; err = St7.St7GetPlateShear2(uID, panelId, ldcsId, shearPressures); localPressure = Vector.ZAxis * (normalPressures[0] - normalPressures[1]) + Vector.XAxis * shearPressures[0] + Vector.YAxis * shearPressures[1]; if (localPressure.Length() > 0) { bhLoads.Add(new AreaUniformlyDistributedLoad() { Loadcase = ldcs, Pressure = localPressure, Objects = panelObjects, Axis = LoadAxis.Local, Projected = false }); } // global pressures double[] globalPressuresZplus = new double[3]; double[] globalPressuresZminus = new double[3]; int projectionFlag = 0; err = St7.St7GetPlateGlobalPressure3S(uID, panelId, St7.psPlateZPlus, ldcsId, ref projectionFlag, globalPressuresZplus); err = St7.St7GetPlateGlobalPressure3S(uID, panelId, St7.psPlateZMinus, ldcsId, ref projectionFlag, globalPressuresZminus); globalPressure = BH.Engine.Geometry.Create.Vector(globalPressuresZplus[0] + globalPressuresZminus[0], globalPressuresZplus[1] + globalPressuresZminus[1], globalPressuresZplus[2] + globalPressuresZminus[2]); bool projected = projectionFlag != St7.ppNone; if (globalPressure.Length() > 0) { bhLoads.Add(new AreaUniformlyDistributedLoad() { Loadcase = ldcs, Pressure = globalPressure, Objects = panelObjects, Axis = LoadAxis.Global, Projected = projected }); } } } return(bhLoads); }
/***************************************************/ private static void SetScales(this Boxes component, Dataset dataset, ViewConfig viewConfig) { BHoMGroup <IBHoMObject> entityGroup = (BHoMGroup <IBHoMObject>)dataset.Data.Find(x => x.Name == "Entities"); List <IBHoMObject> entities = entityGroup.Elements; //set scales List <object> viewX = new List <object>() { 0, viewConfig.Width }; List <object> viewY = new List <object>() { 0, viewConfig.Height }; object allGroupNames = entities.PropertyValue(component.Group); var groups = Convert.ToDataList(allGroupNames).GroupBy(n => n); if (groups.Count() == 0) { Reflection.Compute.RecordError("No groups could be defined with the supplied property name: " + component.Group + "."); return; } int maxGroup = groups.Max(g => g.Count()); List <object> colourNames = Graphics.Convert.ToDataList(entities.PropertyValue(component.Colour)); if (component.IsHorizontal) { //group for x scale m_Xscale = Create.IScale(new List <object>() { 0, maxGroup }, viewX); m_Yscale = Create.IScale(groups.Select(g => g.Key).ToList(), viewY); } else { //group for y scale m_Xscale = Create.IScale(groups.Select(g => g.Key).ToList(), viewX); m_Yscale = Create.IScale(new List <object>() { 0, maxGroup }, viewY); } Gradient gradient = Create.Gradient(); m_Colourscale = Create.IScale(colourNames, gradient.Markers.Values.Cast <object>().ToList()); }
public static BarPointLoad BarPointLoad(Loadcase loadcase, double distFromA, IEnumerable <Bar> objects, Vector force = null, Vector moment = null, LoadAxis axis = LoadAxis.Global, string name = "") { BHoMGroup <Bar> group = new BHoMGroup <Bar>(); if (objects == null) { group = null; } else { group.Elements = objects.ToList(); } return(BarPointLoad(loadcase, group, distFromA, force, moment, axis, name)); }
public static BarUniformlyDistributedLoad BarUniformlyDistributedLoad(Loadcase loadcase, IEnumerable <Bar> objects, Vector force = null, Vector moment = null, LoadAxis axis = LoadAxis.Global, bool projected = false, string name = "") { BHoMGroup <Bar> group = new BHoMGroup <Bar>(); if (objects == null) { group = null; } else { group.Elements = objects.ToList(); } return(BarUniformlyDistributedLoad(loadcase, group, force, moment, axis, projected, name)); }
public static List <BarVaryingDistributedLoad> BarVaryingDistributedLoadDistanceBothEnds(Loadcase loadcase, IEnumerable <Bar> objects, bool relativePositions, double startToStartDistance = 0, Vector forceAtStart = null, Vector momentAtStart = null, double endToEndDistance = 0, Vector forceAtEnd = null, Vector momentAtEnd = null, LoadAxis axis = LoadAxis.Global, bool projected = false, string name = "", double groupingTolerance = Tolerance.Distance) { BHoMGroup <Bar> group = new BHoMGroup <Bar>(); if (objects == null) { group = null; } else { group.Elements = objects.ToList(); } return(BarVaryingDistributedLoadDistanceBothEnds(loadcase, group, relativePositions, startToStartDistance, forceAtStart, forceAtEnd, endToEndDistance, forceAtEnd, momentAtEnd, axis, projected, name, groupingTolerance)); }
public static PointLoad PointLoad(Loadcase loadcase, IEnumerable <Node> objects, Vector force = null, Vector moment = null, LoadAxis axis = LoadAxis.Global, string name = "") { BHoMGroup <Node> group = new BHoMGroup <Node>(); if (objects == null) { group = null; } else { group.Elements = objects.ToList(); } return(PointLoad(loadcase, group, force, moment, axis, name)); }
public static PointVelocity PointVelocity(Loadcase loadcase, IEnumerable <Node> objects, Vector translationalVelocity = null, Vector rotationalVelocity = null, LoadAxis axis = LoadAxis.Global, string name = "") { BHoMGroup <Node> group = new BHoMGroup <Node>(); if (objects == null) { group = null; } else { group.Elements = objects.ToList(); } return(PointVelocity(loadcase, group, translationalVelocity, rotationalVelocity, axis, name)); }
public static BarVaryingDistributedLoad BarVaryingDistributedLoad(Loadcase loadcase, IEnumerable <Bar> objects, double startPosition = 0, Vector forceAtStart = null, Vector momentAtStart = null, double endPosition = 1, Vector forceAtEnd = null, Vector momentAtEnd = null, bool relativePositions = true, LoadAxis axis = LoadAxis.Global, bool projected = false, string name = "") { BHoMGroup <Bar> group = new BHoMGroup <Bar>(); if (objects == null) { group = null; } else { group.Elements = objects.ToList(); } return(BarVaryingDistributedLoad(loadcase, group, startPosition, forceAtStart, momentAtStart, endPosition, forceAtEnd, momentAtEnd, relativePositions, axis, projected, name)); }
public static AreaDifferentialTemperatureLoad AreaDifferentialTemperatureLoad(Loadcase loadcase, List <double> positions, List <double> temperatures, IEnumerable <IAreaElement> objects, string name = "") { if (positions.IsNullOrEmpty() || temperatures.IsNullOrEmpty()) { return(null); } //Checks for positions and profiles if (positions.Count != temperatures.Count) { Reflection.Compute.RecordError("Number of positions and temperatures provided are not equal"); return(null); } else if (positions.Exists((double d) => { return(d > 1); }) || positions.Exists((double d) => { return(d < 0); })) { Reflection.Compute.RecordError("Positions must exist between 0 and 1 (inclusive)"); return(null); } if (positions.Zip(positions.Skip(1), (a, b) => new { a, b }).Any(p => p.a > p.b)) { Reflection.Compute.RecordError("Positions must be sorted in ascending order."); return(null); } //Create ditionary for TaperedProfile Dictionary <double, double> temperatureProfile = positions.Zip(temperatures, (z, t) => new { z, t }) .ToDictionary(x => x.z, x => x.t); BHoMGroup <IAreaElement> group = new BHoMGroup <IAreaElement>(); if (objects == null) { group = null; } else { group.Elements = objects.ToList(); } return(new AreaDifferentialTemperatureLoad { Loadcase = loadcase, TemperatureProfile = temperatureProfile, Objects = group, Name = name }); }
/***************************************************/ public static PointVelocity PointVelocity(Loadcase loadcase, BHoMGroup <Node> group, Vector translation = null, Vector rotation = null, LoadAxis axis = LoadAxis.Global, string name = "") { if (translation == null && rotation == null) { throw new ArgumentException("Point velocity requires either the translation or the rotation vector to be defined"); } return(new PointVelocity { Loadcase = loadcase, Objects = group, TranslationalVelocity = translation == null ? new Vector() : translation, RotationalVelocity = rotation == null ? new Vector() : rotation, Axis = axis, Name = name }); }
/***************************************************/ public static PointForce PointForce(Loadcase loadcase, BHoMGroup <Node> group, Vector force = null, Vector moment = null, LoadAxis axis = LoadAxis.Global, string name = "") { if (force == null && moment == null) { throw new ArgumentException("Point force requires either the force or the moment vector to be defined"); } return(new PointForce { Loadcase = loadcase, Objects = group, Force = force == null ? new Vector() : force, Moment = moment == null ? new Vector() : moment, Axis = axis, Name = name }); }
/***************************************************/ public static BarPointLoad BarPointLoad(Loadcase loadcase, BHoMGroup <Bar> group, double distFromA, Vector force = null, Vector moment = null, LoadAxis axis = LoadAxis.Global, string name = "") { if (force == null && moment == null) { throw new ArgumentException("Bar point load requires either the force or the moment vector to be defined"); } return(new BarPointLoad { Loadcase = loadcase, DistanceFromA = distFromA, Force = force == null ? new Vector() : force, Moment = moment == null ? new Vector() : moment, Objects = group, Axis = axis, Name = name }); }
public static PointVelocity PointVelocity(Loadcase loadcase, BHoMGroup <Node> group, Vector translationalVelocity = null, Vector rotationalVelocity = null, LoadAxis axis = LoadAxis.Global, string name = "") { if (translationalVelocity == null && rotationalVelocity == null) { Reflection.Compute.RecordError("PointVelocity requires at least the translation or the rotation vector to be defined"); return(null); } return(new PointVelocity { Loadcase = loadcase, Objects = group, TranslationalVelocity = translationalVelocity == null ? new Vector() : translationalVelocity, RotationalVelocity = rotationalVelocity == null ? new Vector() : rotationalVelocity, Axis = axis, Name = name }); }
public static BarDistributedMass BarDistributedMass(Loadcase loadcase, BHoMGroup <Bar> group, double distFromA = 0, double massA = 0, double distFromB = 0, double massB = 0, string name = "") { if (massA == 0 && massB == 0) { throw new ArgumentException("Bar distributed mass requires either the mass at A or/and B to be defined"); } return(new BarDistributedMass { Loadcase = loadcase, Objects = group, DistanceFromA = distFromA, DistanceFromB = distFromB, MassA = massA, MassB = massB, Name = name }); }
public static PointLoad PointLoad(Loadcase loadcase, BHoMGroup <Node> group, Vector force = null, Vector moment = null, LoadAxis axis = LoadAxis.Global, string name = "") { if (force == null && moment == null) { Reflection.Compute.RecordError("PointForce requires at least the force or moment vector to be defined"); return(null); } return(new PointLoad { Loadcase = loadcase, Objects = group, Force = force == null ? new Vector() : force, Moment = moment == null ? new Vector() : moment, Axis = axis, Name = name }); }
/***************************************************/ private List <ILoad> ReadAreaTempratureLoad(List <Loadcase> loadcases) { List <ILoad> bhLoads = new List <ILoad>(); Dictionary <string, Panel> bhomPanels = ReadPanel().ToDictionary(x => GetAdapterId <string>(x)); string[] names = null; string[] loadcase = null; int[] myType = null; double[] value = null; int nameCount = 0; string[] patternName = null; if (m_model.AreaObj.GetLoadTemperature("All", ref nameCount, ref names, ref loadcase, ref myType, ref value, ref patternName, 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; } if (myType[i] == 1) { BHoMGroup <IAreaElement> panelObjects = new BHoMGroup <IAreaElement>() { Elements = { bhomPanels[names[i]] } }; bhLoads.Add(new AreaUniformTemperatureLoad() { Loadcase = bhLoadcase, Objects = panelObjects, TemperatureChange = value[i] }); } } return(bhLoads); }
public static BarPointLoad BarPointLoad(Loadcase loadcase, BHoMGroup <Bar> group, double distFromA, Vector force = null, Vector moment = null, LoadAxis axis = LoadAxis.Global, string name = "") { if (force == null && moment == null) { Reflection.Compute.RecordError("BarPointLoad requires at least the force or the moment vector to be defined."); return(null); } return(new BarPointLoad { Loadcase = loadcase, DistanceFromA = distFromA, Force = force == null ? new Vector() : force, Moment = moment == null ? new Vector() : moment, Objects = group, Axis = axis, Name = name }); }
public static BarPrestressLoad BarPrestressLoad(Loadcase loadcase, double prestress, IEnumerable <Bar> objects, string name = "") { BHoMGroup <Bar> group = new BHoMGroup <Bar>(); if (objects == null) { group = null; } else { group.Elements = objects.ToList(); } return(new BarPrestressLoad { Loadcase = loadcase, Prestress = prestress, Objects = group, Name = name }); }
public static GravityLoad GravityLoad(Loadcase loadcase, Vector gravityDirection, IEnumerable <IBHoMObject> objects, string name = "") { BHoMGroup <BHoMObject> group = new BHoMGroup <BHoMObject>(); if (objects == null) { group = null; } else { group.Elements = objects.Cast <BHoMObject>().ToList(); } return(gravityDirection.IsNull() ? null : new GravityLoad { Loadcase = loadcase, GravityDirection = gravityDirection, Objects = group, Name = name }); }
public static AreaUniformlyDistributedLoad AreaUniformlyDistributedLoad(Loadcase loadcase, Vector pressure, IEnumerable <IAreaElement> objects, LoadAxis axis = LoadAxis.Global, bool projected = false, string name = "") { BHoMGroup <IAreaElement> group = new BHoMGroup <IAreaElement>(); if (objects == null) { group = null; } else { group.Elements = objects.ToList(); } return(new AreaUniformlyDistributedLoad { Loadcase = loadcase, Pressure = pressure, Objects = group, Axis = axis, Projected = projected, Name = name }); }
public static BarUniformTemperatureLoad BarUniformTemperatureLoad(Loadcase loadcase, double temperatureChange, IEnumerable <Bar> objects, LoadAxis axis = LoadAxis.Global, bool projected = false, string name = "") { BHoMGroup <Bar> group = new BHoMGroup <Bar>(); if (objects == null) { group = null; } else { group.Elements = objects.ToList(); } return(loadcase.IsNull() ? null : new BarUniformTemperatureLoad { Loadcase = loadcase, TemperatureChange = temperatureChange, Objects = group, Axis = axis, Projected = projected, Name = name }); }
/***************************************************/ /**** Public Methods ****/ /***************************************************/ public static ILoad Load(LoadType type, Loadcase loadCase, List <double> magnitude, string groupName, LoadAxis axis, bool isProjected, string units = "kN") { units = units.ToUpper(); units = units.Replace(" ", ""); double sFac = 1; switch (units) { case "N": case "NEWTON": case "NEWTONS": sFac = 1; break; case "KN": case "KILONEWTON": case "KILONEWTONS": sFac = 1000; break; case "C": case "CELSIUS": case "K": case "KELVIN": sFac = 1; break; default: throw new ArgumentException("Unrecognised unit type"); } Vector force = null; Vector moment = null; double mag; if (magnitude.Count < 1) { throw new ArgumentException("Need at least one maginute value"); } mag = magnitude[0] * sFac; if (magnitude.Count > 2) { force = new Vector() { X = magnitude[0], Y = magnitude[1], Z = magnitude[2] } } *sFac; if (magnitude.Count > 5) { moment = new Vector() { X = magnitude[3], Y = magnitude[4], Z = magnitude[5] } } *sFac; switch (type) { case LoadType.Selfweight: { BHoMGroup <BHoMObject> group = new BHoMGroup <BHoMObject>() { Name = groupName }; return(GravityLoad(loadCase, force, group, groupName)); } case LoadType.PointForce: { BHoMGroup <Node> group = new BHoMGroup <Node>() { Name = groupName }; return(PointForce(loadCase, group, force, moment, axis, groupName)); } case LoadType.PointDisplacement: { BHoMGroup <Node> group = new BHoMGroup <Node>() { Name = groupName }; return(PointDisplacement(loadCase, group, force, moment, axis, groupName)); } case LoadType.PointVelocity: { BHoMGroup <Node> group = new BHoMGroup <Node>() { Name = groupName }; return(PointVelocity(loadCase, group, force, moment, axis, groupName)); } case LoadType.PointAcceleration: { BHoMGroup <Node> group = new BHoMGroup <Node>() { Name = groupName }; return(PointAcceleration(loadCase, group, force, moment, axis, groupName)); } case LoadType.BarUniformLoad: { BHoMGroup <Bar> group = new BHoMGroup <Bar>() { Name = groupName }; return(BarUniformlyDistributedLoad(loadCase, group, force, moment, axis, isProjected, groupName)); } case LoadType.BarTemperature: { BHoMGroup <Bar> group = new BHoMGroup <Bar>() { Name = groupName }; return(BarTemperatureLoad(loadCase, mag, group, axis, isProjected, groupName)); } case LoadType.AreaUniformLoad: { BHoMGroup <IAreaElement> group = new BHoMGroup <IAreaElement>() { Name = groupName }; return(AreaUniformalyDistributedLoad(loadCase, force, group, axis, isProjected, groupName)); } case LoadType.BarVaryingLoad: case LoadType.BarPointLoad: case LoadType.AreaTemperature: case LoadType.Pressure: case LoadType.Geometrical: default: throw new NotImplementedException("Load type not implemented"); } }
/***************************************************/ public static BarVaryingDistributedLoad BarVaryingDistributedLoad(Loadcase loadcase, BHoMGroup <Bar> group, double distFromA = 0, Vector forceA = null, Vector momentA = null, double distFromB = 0, Vector forceB = null, Vector momentB = null, LoadAxis axis = LoadAxis.Global, bool projected = false, string name = "") { if ((forceA == null || forceB == null) && (momentA == null || momentB == null)) { throw new ArgumentException("Bar varying load requires either the force at A and B OR the moment at A and B to be defined"); } return(new BarVaryingDistributedLoad { Loadcase = loadcase, Objects = group, DistanceFromA = distFromA, DistanceFromB = distFromB, ForceA = forceA == null ? new Vector() : forceA, ForceB = forceB == null ? new Vector():forceB, MomentA = momentA == null? new Vector() : momentA, MomentB = momentB == null? new Vector() : momentB, Projected = projected, Axis = axis, Name = name }); }
/***************************************************/ public static BarUniformlyDistributedLoad BarUniformlyDistributedLoad(Loadcase loadcase, BHoMGroup <Bar> group, Vector force = null, Vector moment = null, LoadAxis axis = LoadAxis.Global, bool projected = false, string name = "") { if (force == null && moment == null) { throw new ArgumentException("Bar uniform load requires either the force or the moment vector to be defined"); } return(new BarUniformlyDistributedLoad { Loadcase = loadcase, Objects = group, Force = force == null? new Vector(): force, Moment = moment == null? new Vector():moment, Axis = axis, Name = name, Projected = projected }); }
/***************************************************/ public static BarTemperatureLoad BarTemperatureLoad(Loadcase loadcase, double temperatureChange, BHoMGroup <Bar> group, LoadAxis axis = LoadAxis.Global, bool projected = false, string name = "") { return(new BarTemperatureLoad { Loadcase = loadcase, TemperatureChange = temperatureChange, Objects = group, Axis = axis, Projected = projected, Name = name }); }