public override bool Execute(ExecutionInfo exInfo = null)
{
LoadCase lCase = Model.LoadCases.FindByName(Case);
if (lCase == null || lCase.IsDeleted)
{
lCase = Model.Create.LoadCase(Case, exInfo);
}
GravityLoad nLoad = Model.Create.GravityLoad(lCase, exInfo);
nLoad.Name = Name;
//nLoad.Axes = Axes;
nLoad.Direction = Direction;
nLoad.Value = Value;
if (ApplyTo == null)
{
nLoad.AppliedTo.Clear();
nLoad.AppliedTo.All = true;
}
else
{
nLoad.AppliedTo.Set(ApplyTo);
}
Load = nLoad;
return(true);
}
/***************************************************/
private bool CreateLoad(GravityLoad bhLoad)
{
double selfWeightExisting = 0;
double selfWeightNew = -bhLoad.GravityDirection.Z;
string caseName = GetAdapterId <string>(bhLoad.Loadcase);
m_model.LoadPatterns.GetSelfWTMultiplier(caseName, ref selfWeightExisting);
if (selfWeightExisting != 0)
{
BH.Engine.Base.Compute.RecordWarning($"The self weight for loadcase {bhLoad.Loadcase.Name} will be overwritten. Previous value: {selfWeightExisting}, new value: {selfWeightNew}");
}
m_model.LoadPatterns.SetSelfWTMultiplier(caseName, selfWeightNew);
if (bhLoad.GravityDirection.X != 0 || bhLoad.GravityDirection.Y != 0)
{
Engine.Base.Compute.RecordError("SAP2000 can only handle gravity loads in global z direction");
}
BH.Engine.Base.Compute.RecordNote("SAP2000 handles gravity loads via loadcases, so only one gravity load per loadcase can be used. This gravity load will be applied to all objects.");
SetAdapterId(bhLoad, null);
return(true);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private IFLoadingBody CreateGravityLoad(GravityLoad gravityLoad, IFGeometry[] lusasGeometry)
{
IFLoadingBody lusasGravityLoad;
IFLoadcase assignedLoadcase = (IFLoadcase)d_LusasData.getLoadset(gravityLoad.Loadcase.AdapterId <int>(typeof(LusasId)));
if (d_LusasData.existsAttribute("Loading", gravityLoad.Name))
{
lusasGravityLoad = (IFLoadingBody)d_LusasData.getAttributes("Loading", gravityLoad.Name);
}
else
{
lusasGravityLoad = d_LusasData.createLoadingBody(gravityLoad.Name);
lusasGravityLoad.setBody(gravityLoad.GravityDirection.X, gravityLoad.GravityDirection.Y, gravityLoad.GravityDirection.Z);
}
IFAssignment lusasAssignment = m_LusasApplication.assignment();
lusasAssignment.setLoadset(assignedLoadcase);
lusasGravityLoad.assignTo(lusasGeometry, lusasAssignment);
int adapterIdName = lusasGravityLoad.getID();
gravityLoad.SetAdapterId(typeof(LusasId), adapterIdName);
return(lusasGravityLoad);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static GravityLoad ToGravityLoad(IFLoading lusasGravityLoad,
IEnumerable <IFAssignment> lusasAssignments,
Dictionary <string, Node> nodes,
Dictionary <string, Bar> bars,
Dictionary <string, Panel> panels)
{
IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset();
Loadcase loadcase = ToLoadcase(assignedLoadcase);
Vector gravityVector = new Vector
{
X = lusasGravityLoad.getValue("accX"),
Y = lusasGravityLoad.getValue("accY"),
Z = lusasGravityLoad.getValue("accZ")
};
IEnumerable <BHoMObject> assignedObjects = GetGeometryAssignments(
lusasAssignments, nodes, bars, panels);
GravityLoad gravityLoad = Engine.Structure.Create.GravityLoad(
loadcase, gravityVector, assignedObjects, GetName(lusasGravityLoad));
int adapterNameId = lusasGravityLoad.getID();
gravityLoad.SetAdapterId(typeof(LusasId), adapterNameId);
return(gravityLoad);
}
// [Category("QuickTests")]
public void FindSupportNode()
{
var nFaces = 1;
var length = 10.0;
var xIncMesh = length / nFaces;
var limit_dist = xIncMesh / 100.0;
// create the mesh
var mesh = new Mesh3((nFaces + 1) * 2, nFaces);
mesh.AddVertex(new Point3(0, -0.5, 0));
mesh.AddVertex(new Point3(0, 0.5, 0));
for (var faceInd = 0; faceInd < nFaces; ++faceInd)
{
mesh.AddVertex(new Point3((faceInd + 1) * xIncMesh, -0.5, 0));
mesh.AddVertex(new Point3((faceInd + 1) * xIncMesh, 0.5, 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, -0.5, 0), new List <bool>()
{
true, true, true, true, true, true
}, Plane3.Default);
var support2 = new Support(new Point3(0, 0.5, 0), new List <bool>()
{
true, true, true, true, true, true
}, Plane3.Default);
// create a gravity load
var gravityLoad = new GravityLoad(new Vector3(0, 0, -1));
// 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>()
{
gravityLoad
}, 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], 53.621934860880543, 1E-5);
Assert.AreEqual(outMaxDisp[0], 53.62193486094136, 1E-5);
}
public void FindSupportNode()
{
var k3d = new Toolkit();
var nFaces = 1;
var length = 10.0;
var xIncMesh = length / nFaces;
var limit_dist = xIncMesh / 100.0;
// create the mesh
var mesh = new Mesh();
mesh.Vertices.Add(new Point3d(0, -0.5, 0));
mesh.Vertices.Add(new Point3d(0, 0.5, 0));
for (var faceInd = 0; faceInd < nFaces; ++faceInd)
{
mesh.Vertices.Add(new Point3d((faceInd + 1) * xIncMesh, -0.5, 0));
mesh.Vertices.Add(new Point3d((faceInd + 1) * xIncMesh, 0.5, 0));
var nV = mesh.Vertices.Count;
mesh.Faces.AddFace(new MeshFace(nV - 4, nV - 3, nV - 1, nV - 2));
}
// create a shell
var outLogger = new MessageLogger();
var outBuilderShells = k3d.Part.MeshToShell(new List <Mesh3>()
{
mesh.Convert()
}, new List <string>(), new List <CroSec>(),
outLogger, out var outPoints);
// create two supports
var support1 = k3d.Support.Support(new Point3(0, -0.5, 0), k3d.Support.SupportFixedConditions);
var support2 = k3d.Support.Support(new Point3(0, 0.5, 0), k3d.Support.SupportFixedConditions);
// create a gravity load
var gravityLoad = new GravityLoad(new Vector3(0, 0, -1));
// assemble the model
var model = k3d.Model.AssembleModel(outBuilderShells, new List <Support>()
{
support1, support2
},
new List <Load>()
{
gravityLoad
}, out var info, out var mass, out var cog, out var warning, out var runtimeWarning);
var targetMass = length * 0.01 * 7850;
Assert.AreEqual(mass, targetMass, 1E-5);
ThIAnalyze.solve(model, out var outMaxDisp, out var outG, out var outComp, out warning, out model);
// Assert.AreEqual(outMaxDisp[0], 34.137028934059728, 1E-5);
Assert.AreEqual(outMaxDisp[0], 53.621934860941359, 1E-5);
}
public PixelStructure()
{
this.Nodes = new List <Point2d>();
this.DispNodes = new List <Point2d>();
this.Edges = new List <Edge>();
this.AllEdgeColors = new List <Color>();
this.Pixels = new List <Pixel>();
this.WindLoad = new WindLoad();
this.GravityLoad = new GravityLoad();
}
/***************************************************/
/**** Private methods ****/
/***************************************************/
private bool CreateObject(GravityLoad gravityLoad)
{
int err = 0;
Loadcase loadcase = gravityLoad.Loadcase;
int loadCaseId = GetAdapterId <int>(loadcase);
err = St7.St7SetLoadCaseType(1, loadCaseId, St7.lcGravity);
err = St7.St7EnableLSALoadCase(1, loadCaseId, 1);
if (!St7ErrorCustom(err, "Couldn't set gravity for a loadcase " + loadCaseId))
{
return(false);
}
int gravityDir = 0;
if (gravityLoad.GravityDirection.X != 0)
{
gravityDir = 1;
}
if (gravityLoad.GravityDirection.Y != 0)
{
gravityDir = 2;
}
if (gravityLoad.GravityDirection.Z != 0)
{
gravityDir = 3;
}
err = St7.St7SetLoadCaseGravityDir(1, loadCaseId, gravityDir);
if (!St7ErrorCustom(err, "Couldn't set gravity direction for a loadcase " + loadCaseId))
{
return(false);
}
int[] units = new int[St7.kLastUnit];
err = St7.St7GetUnits(1, units);
if (!St7ErrorCustom(err, "Couldn't get default units for a loadcase " + loadCaseId))
{
return(false);
}
double temp = St7TempFromTUnints(units[St7.ipTEMPERU]);
double accel = St7AccelerationFromLUnints(units[St7.ipLENGTHU]);
// Load case defaults array
double[] loadVals = new double[13];
loadVals[St7.ipLoadCaseRefTemp] = temp;
loadVals[St7.ipLoadCaseAccX] = gravityDir == 1 ? accel : 0;
loadVals[St7.ipLoadCaseAccY] = gravityDir == 2 ? accel : 0;
loadVals[St7.ipLoadCaseAccZ] = gravityDir == 3 ? accel : 0;
err = St7.St7SetLoadCaseDefaults(1, loadCaseId, loadVals);
if (!St7ErrorCustom(err, "Couldn't set gravity acceleration for a loadcase " + loadCaseId))
{
return(false);
}
return(true);
}
public static List <ICurve> Visualize(this GravityLoad gravityLoad, double scaleFactor = 1.0, bool displayForces = true, bool displayMoments = true, bool asResultants = true)
{
if (gravityLoad.IsNull())
{
return(null);
}
List <ICurve> arrows = new List <ICurve>();
Vector gravityDir = gravityLoad.GravityDirection * scaleFactor * 9.80665;
int barDivisions = 5;
foreach (BH.oM.Base.BHoMObject obj in gravityLoad.Objects.Elements)
{
if (obj is Bar)
{
Bar bar = obj as Bar;
if (bar.SectionProperty == null || bar.SectionProperty.Material == null)
{
Reflection.Compute.RecordWarning("Bar needs a valid sectionproperty and material to display gravity loading");
continue;
}
Vector loadVector = bar.SectionProperty.IMassPerMetre() * gravityDir;
List <Point> pts = DistributedPoints(bar, barDivisions);
if (displayForces)
{
arrows.AddRange(ConnectedArrows(new List <ICurve> {
bar.Centreline()
}, loadVector, true, null, 1, true));
}
}
else if (obj is IAreaElement)
{
IAreaElement element = obj as IAreaElement;
Vector loadVector = element.Property.IMassPerArea() * gravityDir;
if (displayForces)
{
arrows.AddRange(ConnectedArrows(element.IEdges(), loadVector, true));
}
}
else
{
Reflection.Compute.RecordWarning("Display for gravity loads only implemented for Bars and IAreaElements. No area elements will be displayed");
}
}
return(arrows);
}
public PixelStructure(List <Point2d> nodes, List <Pixel> pixels)
{
this.Nodes = nodes;
this.Pixels = pixels;
this.DispNodes = new List <Point2d>();
// Generates edges from pixels
var allEdges = pixels.SelectMany(p => p.GetEdges());
Edges = allEdges.Distinct().ToList();
this.AllEdgeColors = new List <Color>();
this.WindLoad = new WindLoad();
this.GravityLoad = new GravityLoad();
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private List <ILoad> ReadGravityLoads(List <string> ids = null)
{
List <ILoad> gravityLoads = new List <ILoad>();
object[] lusasBodyForces = d_LusasData.getAttributes("Body Force Load");
if (!(lusasBodyForces.Count() == 0))
{
List <Node> nodesList = ReadNodes();
List <Bar> barsList = ReadBars();
List <Panel> panelsList = ReadPanels();
Dictionary <string, Node> nodes = nodesList.ToDictionary(
x => x.AdapterId <string>(typeof(LusasId)));
Dictionary <string, Bar> bars = barsList.ToDictionary(
x => x.AdapterId <string>(typeof(LusasId)));
Dictionary <string, Panel> panels = panelsList.ToDictionary(
x => x.AdapterId <string>(typeof(LusasId)));
List <IFLoadcase> allLoadcases = new List <IFLoadcase>();
for (int i = 0; i < lusasBodyForces.Count(); i++)
{
IFLoading lusasBodyForce = (IFLoading)lusasBodyForces[i];
IEnumerable <IGrouping <string, IFAssignment> > groupedByLoadcases =
GetLoadAssignments(lusasBodyForce);
foreach (IEnumerable <IFAssignment> groupedAssignment in groupedByLoadcases)
{
List <string> analysisName = new List <string> {
lusasBodyForce.getAttributeType()
};
GravityLoad gravityLoad = Adapters.Lusas.Convert.ToGravityLoad(
lusasBodyForce, groupedAssignment, nodes, bars, panels);
gravityLoad.Tags = new HashSet <string>(analysisName);
gravityLoads.Add(gravityLoad);
}
}
}
return(gravityLoads);
}
public static void SetLoad(cSapModel model, GravityLoad gravityLoad, bool replace)
{
int ret = 0;
double selfWeightMultiplier = 0;
model.LoadPatterns.GetSelfWTMultiplier(CaseNameToCSI(gravityLoad.Loadcase), ref selfWeightMultiplier);
if (selfWeightMultiplier != 0)
{
BH.Engine.Reflection.Compute.RecordWarning($"Loadcase {gravityLoad.Loadcase.Name} allready had a selfweight multiplier which will get overridden. Previous value: {selfWeightMultiplier}, new value: {-gravityLoad.GravityDirection.Z}");
}
model.LoadPatterns.SetSelfWTMultiplier(CaseNameToCSI(gravityLoad.Loadcase), -gravityLoad.GravityDirection.Z);
if (gravityLoad.GravityDirection.X != 0 || gravityLoad.GravityDirection.Y != 0)
{
Engine.Reflection.Compute.RecordError("Etabs can only handle gravity loads in global z direction");
}
BH.Engine.Reflection.Compute.RecordWarning("Etabs handles gravity loads via loadcases, why only one gravity load per loadcase can be used. THis gravity load will be applied to all objects");
}
/***************************************************/
public void SetLoad(GravityLoad gravityLoad, bool replace)
{
double selfWeightMultiplier = 0;
string caseName = GetAdapterId <string>(gravityLoad.Loadcase);
m_model.LoadPatterns.GetSelfWTMultiplier(caseName, ref selfWeightMultiplier);
if (selfWeightMultiplier != 0)
{
BH.Engine.Base.Compute.RecordWarning($"Loadcase {gravityLoad.Loadcase.Name} allready had a selfweight multiplier which will get overridden. Previous value: {selfWeightMultiplier}, new value: {-gravityLoad.GravityDirection.Z}");
}
m_model.LoadPatterns.SetSelfWTMultiplier(caseName, -gravityLoad.GravityDirection.Z);
if (gravityLoad.GravityDirection.X != 0 || gravityLoad.GravityDirection.Y != 0)
{
Engine.Base.Compute.RecordError("ETABS can only handle gravity loads in global z direction");
}
BH.Engine.Base.Compute.RecordWarning("ETABS handles gravity loads via loadcases, why only one gravity load per loadcase can be used. THis gravity load will be applied to all objects");
}
public static LoadType LoadType(this GravityLoad load)
{
return(oM.Structure.Loads.LoadType.Selfweight);
}
public GsaGravityLoad()
{
m_gravityload = new GravityLoad();
}
public FEResults Analyze()
{
var license_path = Karamba.Licenses.License.licensePath();
var license = Karamba.Licenses.License.getLicense();
var has_expired = Karamba.Licenses.License.has_expired();
var license_type = Karamba.Licenses.License.licenseType();
var k3d = new Toolkit();
var logger = new MessageLogger();
// create beam elements
var lines = new List <Line3>();
var colSecs = new List <CroSec>();
for (int i = 0; i < modelGeo.Beams.Count; i++)
{
Beam b = modelGeo.Beams[i];
double l = Math.Max(Points.Distance(b.Section[0], b.Section[1]), Points.Distance(b.Section[1], b.Section[2]));
double w = Math.Min(Points.Distance(b.Section[0], b.Section[1]), Points.Distance(b.Section[1], b.Section[2]));
Vector3 v = new Vector3((b.End.X - b.Start.X) / beamDisc, (b.End.Y - b.Start.Y) / beamDisc, (b.End.Z - b.Start.Z) / beamDisc);
var nodeI = new Point3(b.Start.X, b.Start.Y, b.Start.Z);
for (int beamInd = 0; beamInd < beamDisc; ++beamInd)
{
var nodeK = new Point3(nodeI.X + v.X, nodeI.Y + v.Y, nodeI.Z + v.Z);
lines.Add(new Line3(nodeI, nodeK));
colSecs.Add(k3d.CroSec.Box(height: l, uf_thick: w, lf_width: w));
nodeI = nodeK;
}
}
List <ShellMesh> shellMeshes = CreateMesh();
List <Mesh3> slabMeshes = shellMeshes.Where(sm => sm.Shell.type == ShellType.Slab).Select(s => s.Mesh).ToList();
List <Mesh3> wallMeshes = shellMeshes.Where(sm => sm.Shell.type == ShellType.Wall).Select(s => s.Mesh).ToList();
// materials
FemMaterial C4050 = new FemMaterial_Isotrop("concrete", "C40/50", 35e6, 14.58e6, 14.58e6, 25, 40e3, 0, System.Drawing.Color.Blue);
// cross-sections
List <CroSec> slabSecs = slabMeshes.SelectMany(s => new List <CroSec> {
k3d.CroSec.ShellConst(height: 0.250)
}).ToList();; // be careful with units (most likely) in cm !!
List <CroSec> wallSecs = wallMeshes.SelectMany(s => new List <CroSec> {
k3d.CroSec.ShellConst(height: 0.300)
}).ToList();; // be careful with units (most likely) in cm !!
colSecs.ForEach(c => c.setMaterial(C4050));
slabSecs.ForEach(c => c.setMaterial(C4050));
wallSecs.ForEach(c => c.setMaterial(C4050));
// FE elements
var slabElements = k3d.Part.MeshToShell(slabMeshes, new List <string>(), slabSecs, logger, out List <Point3> outSlabPoints);
var wallElements = k3d.Part.MeshToShell(wallMeshes, new List <string>(), wallSecs, logger, out List <Point3> outWallPoints);
var beamElements = k3d.Part.LineToBeam(lines, new List <string>(), colSecs, logger, out List <Point3> outColPoints);
List <BuilderElement> elements = new List <BuilderElement>(slabElements);
elements.AddRange(wallElements);
elements.AddRange(beamElements);
// ------ LOADS ---------
List <Load> loads = new List <Load>();
// mesh loads on slabs
List <Load> slabLoads = new List <Load>();
for (int i = 0; i < slabMeshes.Count; i++)
{
slabLoads.Add(k3d.Load.MeshLoad(new List <Vector3> {
new Vector3(0, 0, -2.5)
}, slabMeshes[i]));
}
//loads.AddRange(slabLoads);
// gravity
GravityLoad gravity = new GravityLoad(new Vector3(0, 0, -1), 0);
loads.Add(gravity);
// supports
var colSupports = modelGeo.Beams.Where(b => b.Start.Z == 0)
.Select(b => k3d.Support.Support(new Point3(b.Start.X, b.Start.Y, 0), k3d.Support.SupportFixedConditions)).ToList();
var wallSupports = wallMeshes.SelectMany(m => m.Vertices.Where(v => v.Z == 0)
.Select(v => k3d.Support.Support(new Point3(v.X, v.Y, v.Z), k3d.Support.SupportFixedConditions))).ToList();
var supports = colSupports;
supports.AddRange(wallSupports);
// assemble the model
var model = k3d.Model.AssembleModel(elements, supports, loads, out string info, out double mass, out Point3 cog, out string msg, out bool runtimeWarning);
// calculate the model
model = k3d.Algorithms.AnalyzeThI(model, out var maxDisp, out var outG, out var outComp, out var warning);
Karamba.Results.NodalDisp.solve(model, 0, out var trans, out var rot);
// OUTPUTS
List <MWVector3D> pointDisps = new List <MWVector3D>();
List <MWPoint3D> points = new List <MWPoint3D>();
for (int i = 0; i < model.nodes.Count; i++)
{
var n0 = model.nodes[i].pos;
var n1 = trans[i];
points.Add(new MWPoint3D(n0.X, n0.Y, n0.Z));
pointDisps.Add(new MWVector3D(n1.X / 10.0, n1.Y / 10.0, n1.Z / 10.0));
}
List <int[]> t3 = new List <int[]>();
List <int[]> l2 = new List <int[]>();
for (int i = 0; i < model.elems.Count; i++)
{
if (model.elems[i] is ModelShell e)
{
var m = e.mesh;
for (int j = 0; j < m.Faces.Count; j++)
{
t3.Add(new int[] { e.fe_node_ind[m.Faces[j][0]],
e.fe_node_ind[m.Faces[j][1]],
e.fe_node_ind[m.Faces[j][2]] });
}
}
if (model.elems[i] is ModelBeam b)
{
l2.Add(new int[] { b.fe_node_ind[0], b.fe_node_ind[1] });
}
}
FEResults fer = new FEResults()
{
PointsPos = points.Select(p => new MWPoint3D(p.X, p.Y, p.Z)).ToList(),
PointsDisps = pointDisps.Select(p => new MWVector3D(p.X, p.Y, p.Z)).ToList(),
T3 = t3,
L2 = l2,
MaxDeflection = pointDisps.Max(p => Math.Abs(p.Z)) * 1e3,
MaxDrift = pointDisps.Max(d => Math.Sqrt(d.X * d.X + d.Y * d.Y)) * 1e3,
NumberElems = model.elems.Count
};
return(fer);
//return (points.Select(p => new MWPoint3D(p.X, p.Y, p.Z)).ToList(), t3);
}
public void addGload(GravityLoad gload, Model karambaModel)
{
_gloads_table.Rows.Add("Gravity", (double)gload.force.Z, gload.loadcase);
}
