/***************************************************/
/**** 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);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static PointDisplacement ToPointDisplacement(IFLoading lusasPrescribedDisplacement,
IEnumerable <IFAssignment> lusasAssignments, Dictionary <string, Node> nodes)
{
IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset();
Loadcase loadcase = ToLoadcase(assignedLoadcase);
IEnumerable <Node> assignedNodes = GetPointAssignments(lusasAssignments, nodes);
Vector translationVector = new Vector
{
X = lusasPrescribedDisplacement.getValue("U"),
Y = lusasPrescribedDisplacement.getValue("V"),
Z = lusasPrescribedDisplacement.getValue("W")
};
Vector rotationVector = new Vector
{
X = lusasPrescribedDisplacement.getValue("THX"),
Y = lusasPrescribedDisplacement.getValue("THY"),
Z = lusasPrescribedDisplacement.getValue("THZ")
};
PointDisplacement pointDisplacement = BH.Engine.Structure.Create.PointDisplacement(
loadcase, assignedNodes, translationVector, rotationVector, LoadAxis.Global,
GetName(lusasPrescribedDisplacement));
int adapterNameId = lusasPrescribedDisplacement.getID();
pointDisplacement.SetAdapterId(typeof(LusasId), adapterNameId);
// Needs to be a bit here that determines whether it is global or local - actually this cannot be done as the
//attribute is applied to a group, and within the group the axis could local or global
return(pointDisplacement);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static AreaUniformTemperatureLoad ToAreaTempratureLoad(
IFLoading lusasTemperatureLoad,
IEnumerable <IFAssignment> lusasAssignments,
Dictionary <string, Panel> panels)
{
IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset();
Loadcase loadcase = ToLoadcase(assignedLoadcase);
double temperatureChange = lusasTemperatureLoad.getValue("T")
- lusasTemperatureLoad.getValue("T0");
IEnumerable <IAreaElement> assignedPanels = GetSurfaceAssignments(lusasAssignments, panels);
AreaUniformTemperatureLoad AreaUniformTemperatureLoad = BH.Engine.Structure.Create.AreaUniformTemperatureLoad(
loadcase,
temperatureChange,
assignedPanels,
LoadAxis.Local,
false,
GetName(lusasTemperatureLoad));
int adapterNameId = lusasTemperatureLoad.getID();
AreaUniformTemperatureLoad.SetAdapterId(typeof(LusasId), adapterNameId);
return(AreaUniformTemperatureLoad);
}
/***************************************************/
private IFLoadingGlobalDistributed CreateGlobalDistributed(string lusasName,
string type, IFLoadcase assignedLoadcase, Vector force, Vector moment, object[] lusasGeometry)
{
IFLoadingGlobalDistributed lusasGlobalDistributed;
if (d_LusasData.existsAttribute("Loading", lusasName))
{
lusasGlobalDistributed = (IFLoadingGlobalDistributed)d_LusasData.getAttribute("Loading", lusasName);
}
else
{
lusasGlobalDistributed = d_LusasData.createLoadingGlobalDistributed(lusasName);
if (type == "Length")
{
lusasGlobalDistributed.setGlobalDistributed(type,
force.X, force.Y, force.Z, moment.X, moment.Y, moment.Z);
}
else if (type == "Area")
{
lusasGlobalDistributed.setGlobalDistributed(type,
force.X, force.Y, force.Z);
}
}
IFAssignment lusasAssignment = m_LusasApplication.assignment();
lusasAssignment.setLoadset(assignedLoadcase);
lusasGlobalDistributed.assignTo(lusasGeometry, lusasAssignment);
return(lusasGlobalDistributed);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static BarUniformTemperatureLoad ToBarUniformTemperatureLoad(
IFLoading lusasTemperatureLoad,
IEnumerable <IFAssignment> lusasAssignments,
Dictionary <string, Bar> bars)
{
IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset();
Loadcase loadcase = ToLoadcase(assignedLoadcase);
double temperatureChange = lusasTemperatureLoad.getValue("T")
- lusasTemperatureLoad.getValue("T0");
IEnumerable <Bar> assignedBars = GetLineAssignments(lusasAssignments, bars);
BarUniformTemperatureLoad barUniformTemperatureLoad = Engine.Structure.Create.BarUniformTemperatureLoad(
loadcase,
temperatureChange,
assignedBars,
LoadAxis.Local,
false,
GetName(lusasTemperatureLoad));
int adapterNameId = lusasTemperatureLoad.getID();
barUniformTemperatureLoad.SetAdapterId(typeof(LusasId), adapterNameId);
return(barUniformTemperatureLoad);
}
/***************************************************/
/**** 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 IFPrescribedDisplacementLoad CreatePrescribedDisplacement(PointDisplacement pointDisplacement, object[] lusasPoints)
{
IFPrescribedDisplacementLoad lusasPrescribedDisplacement;
IFLoadcase assignedLoadcase = (IFLoadcase)d_LusasData.getLoadset(pointDisplacement.Loadcase.AdapterId <int>(typeof(LusasId)));
if (d_LusasData.existsAttribute("Loading", pointDisplacement.Name))
{
lusasPrescribedDisplacement = (IFPrescribedDisplacementLoad)d_LusasData.getAttribute("Loading", pointDisplacement.Name);
}
else
{
List <string> valueNames = new List <string> {
"u", "v", "w", "thx", "thy", "thz"
};
List <string> boolCheck = new List <string> {
"haveDispX", "haveDispY", "haveDispZ",
"haveRotX", "haveRotY", "haveRotZ"
};
List <double> displacements = new List <double>
{
pointDisplacement.Translation.X, pointDisplacement.Translation.Y,
pointDisplacement.Translation.Z,
pointDisplacement.Rotation.X, pointDisplacement.Rotation.Y,
pointDisplacement.Rotation.Z
};
lusasPrescribedDisplacement = d_LusasData.createPrescribedDisplacementLoad(
pointDisplacement.Name, "Total");
for (int i = 0; i < valueNames.Count(); i++)
{
if (!(displacements[i] == 0))
{
lusasPrescribedDisplacement.setValue(boolCheck[i], true);
lusasPrescribedDisplacement.setValue(valueNames[i], displacements[i]);
}
else
{
lusasPrescribedDisplacement.setValue(boolCheck[i], false);
}
}
}
IFAssignment lusasAssignment = m_LusasApplication.assignment();
lusasAssignment.setLoadset(assignedLoadcase);
lusasPrescribedDisplacement.assignTo(lusasPoints, lusasAssignment);
int adapterIdName = lusasPrescribedDisplacement.getID();
pointDisplacement.SetAdapterId(typeof(LusasId), adapterIdName);
return(lusasPrescribedDisplacement);
}
/***************************************************/
private IFLoadingGlobalDistributed CreateGlobalDistributedLoadSurface(AreaUniformlyDistributedLoad distributedLoad, object[] lusasSurfaces)
{
IFLoadcase assignedLoadcase = (IFLoadcase)d_LusasData.getLoadset(distributedLoad.Loadcase.AdapterId <int>(typeof(LusasId)));
IFLoadingGlobalDistributed lusasGlobalDistributed = CreateGlobalDistributed(distributedLoad.Name,
"Area", assignedLoadcase, distributedLoad.Pressure, null, lusasSurfaces);
int adapterIdName = lusasGlobalDistributed.getID();
distributedLoad.SetAdapterId(typeof(LusasId), adapterIdName);
return(lusasGlobalDistributed);
}
/***************************************************/
private IFLoadingLocalDistributed CreateLocalDistributedLine(BarUniformlyDistributedLoad distributedLoad, object[] lusasLines)
{
IFLoadcase assignedLoadcase = (IFLoadcase)d_LusasData.getLoadset(distributedLoad.Loadcase.AdapterId <int>(typeof(LusasId)));
IFLoadingLocalDistributed lusasLocalDistributed = CreateLocalDistributed(distributedLoad.Name,
"Line", assignedLoadcase, distributedLoad.Force, lusasLines);
int adapterIdName = lusasLocalDistributed.getID();
distributedLoad.SetAdapterId(typeof(LusasId), adapterIdName);
return(lusasLocalDistributed);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static BarUniformlyDistributedLoad ToBarUniformlyDistributed(IFLoading lusasDistributed,
IEnumerable<IFAssignment> lusasAssignments, Dictionary<string, Bar> bars)
{
IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset();
Loadcase loadcase = ToLoadcase(assignedLoadcase);
IEnumerable<Bar> assignedBars = GetLineAssignments(lusasAssignments, bars);
Vector forceVector = new Vector
{
X = lusasDistributed.getValue("WX"),
Y = lusasDistributed.getValue("WY"),
Z = lusasDistributed.getValue("WZ")
};
BarUniformlyDistributedLoad barUniformlyDistributed = null;
if (lusasDistributed.getAttributeType() == "Global Distributed Load")
{
Vector momentVector = new Vector
{
X = lusasDistributed.getValue("MX"),
Y = lusasDistributed.getValue("MY"),
Z = lusasDistributed.getValue("MZ")
};
barUniformlyDistributed = Engine.Structure.Create.BarUniformlyDistributedLoad(
loadcase,
assignedBars,
forceVector,
momentVector,
LoadAxis.Global,
true,
GetName(lusasDistributed));
}
else if (lusasDistributed.getAttributeType() == "Distributed Load")
{
barUniformlyDistributed = Engine.Structure.Create.BarUniformlyDistributedLoad(
loadcase,
assignedBars,
forceVector,
null,
LoadAxis.Local,
true,
GetName(lusasDistributed));
}
int adapterNameId = lusasDistributed.getID();
barUniformlyDistributed.SetAdapterId(typeof(LusasId), adapterNameId);
return barUniformlyDistributed;
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private IFLoadingTemperature CreateBarUniformTemperatureLoad(BarUniformTemperatureLoad temperatureLoad, object[] lusasLines)
{
IFLoadcase assignedLoadcase = (IFLoadcase)d_LusasData.getLoadset(temperatureLoad.Loadcase.AdapterId <int>(typeof(LusasId)));
IFLoadingTemperature lusasTemperatureLoad = CreateTemperatureLoad(
temperatureLoad.Name, temperatureLoad.TemperatureChange, lusasLines, assignedLoadcase);
int adapterIdName = lusasTemperatureLoad.getID();
temperatureLoad.SetAdapterId(typeof(LusasId), adapterIdName);
return(lusasTemperatureLoad);
}
/***************************************************/
private bool CreateCollection(IEnumerable <Loadcase> loadcases)
{
foreach (Loadcase loadcase in loadcases)
{
IFLoadcase lusasLoadcase = CreateLoadcase(loadcase);
if (lusasLoadcase == null)
{
return(false);
}
}
return(true);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static Loadcase ToLoadcase(this IFLoadcase lusasLoadcase)
{
Loadcase loadcase = new Loadcase
{
Name = GetName(lusasLoadcase),
Number = lusasLoadcase.getID()
};
int adapterNameId = lusasLoadcase.getID();
loadcase.SetAdapterId(typeof(LusasId), adapterNameId);
return(loadcase);
}
/***************************************************/
internal static string GetName(IFLoadcase lusasLoadcase)
{
string loadcaseName = "";
if (lusasLoadcase.getName().Contains("/"))
{
loadcaseName = lusasLoadcase.getName().Substring(
lusasLoadcase.getName().LastIndexOf("/") + 1);
}
else
{
loadcaseName = lusasLoadcase.getName();
}
return(loadcaseName);
}
/***************************************************/
internal static int GetAdapterID(IFLoadcase lusasLoadcase, char lastCharacter)
{
int adapterID = 0;
lusasLoadcase.getName();
if (lusasLoadcase.getName().Contains("/"))
{
adapterID = int.Parse(lusasLoadcase.getName().Split(lastCharacter, '/')[1]);
}
else
{
adapterID = lusasLoadcase.getID();
}
return(adapterID);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static AreaUniformlyDistributedLoad ToAreaUniformlyDistributed(
IFLoading lusasDistributed, IEnumerable <IFAssignment> lusasAssignments,
Dictionary <string, Panel> panels)
{
IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset();
Loadcase loadcase = ToLoadcase(assignedLoadcase);
IEnumerable <IAreaElement> assignedPanels = GetSurfaceAssignments(
lusasAssignments, panels);
Vector pressureVector = new Vector
{
X = lusasDistributed.getValue("WX"),
Y = lusasDistributed.getValue("WY"),
Z = lusasDistributed.getValue("WZ")
};
AreaUniformlyDistributedLoad areaUniformlyDistributedLoad = null;
if (lusasDistributed.getAttributeType() == "Global Distributed Load")
{
areaUniformlyDistributedLoad = Engine.Structure.Create.AreaUniformlyDistributedLoad(
loadcase,
pressureVector,
assignedPanels,
LoadAxis.Global,
true,
GetName(lusasDistributed));
}
else if (lusasDistributed.getAttributeType() == "Distributed Load")
{
areaUniformlyDistributedLoad = Engine.Structure.Create.AreaUniformlyDistributedLoad(
loadcase,
pressureVector,
assignedPanels,
LoadAxis.Local,
true,
GetName(lusasDistributed));
}
int adapterNameId = lusasDistributed.getID();
areaUniformlyDistributedLoad.SetAdapterId(typeof(LusasId), adapterNameId);
return(areaUniformlyDistributedLoad);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private List <Loadcase> ReadLoadcases(List <string> ids = null)
{
List <Loadcase> loadcases = new List <Loadcase>();
object[] allLoadcases = d_LusasData.getLoadsets("loadcase", "all");
for (int i = 0; i < allLoadcases.Count(); i++)
{
IFLoadcase lusasLoadcase = (IFLoadcase)allLoadcases[i];
Loadcase loadcase = Adapters.Lusas.Convert.ToLoadcase(lusasLoadcase);
List <string> analysisName = new List <string> {
lusasLoadcase.getAnalysis().getName()
};
loadcase.Tags = new HashSet <string>(analysisName);
loadcases.Add(loadcase);
}
return(loadcases);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static BarPointLoad ToBarPointLoad(IFLoading lusasBarPointLoad,
IEnumerable <IFAssignment> lusasAssignments, Dictionary <string, Bar> bars)
{
IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset();
Loadcase loadcase = ToLoadcase(assignedLoadcase);
IEnumerable <Bar> assignedBars = GetLineAssignments(lusasAssignments, bars);
Vector forceVector = new Vector
{
X = lusasBarPointLoad.getValue("PX"),
Y = lusasBarPointLoad.getValue("PY"),
Z = lusasBarPointLoad.getValue("PZ")
};
Vector momentVector = new Vector
{
X = lusasBarPointLoad.getValue("MX"),
Y = lusasBarPointLoad.getValue("MY"),
Z = lusasBarPointLoad.getValue("MZ")
};
double forcePosition = lusasBarPointLoad.getValue("Distance");
BarPointLoad barPointLoad;
barPointLoad = Engine.Structure.Create.BarPointLoad(
loadcase,
forcePosition,
assignedBars,
forceVector,
momentVector,
LoadAxis.Global,
GetName(lusasBarPointLoad));
int adapterNameId = lusasBarPointLoad.getID();
barPointLoad.SetAdapterId(typeof(LusasId), adapterNameId);
return(barPointLoad);
}
/***************************************************/
private IFLoadingLocalDistributed CreateLocalDistributed(string lusasName,
string type, IFLoadcase assignedLoadcase, Vector force, object[] lusasGeometry)
{
IFLoadingLocalDistributed lusasLocalDistributed;
if (d_LusasData.existsAttribute("Loading", lusasName))
{
lusasLocalDistributed = (IFLoadingLocalDistributed)d_LusasData.getAttribute("Loading", lusasName);
}
else
{
lusasLocalDistributed = d_LusasData.createLoadingLocalDistributed(lusasName);
lusasLocalDistributed.setLocalDistributed(force.X, force.Y, force.Z, type);
}
IFAssignment lusasAssignment = m_LusasApplication.assignment();
lusasAssignment.setLoadset(assignedLoadcase);
lusasLocalDistributed.assignTo(lusasGeometry, lusasAssignment);
return(lusasLocalDistributed);
}
/***************************************************/
/**** 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);
}
/***************************************************/
/**** 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 Methods ****/
/***************************************************/
public static BarVaryingDistributedLoad ToBarDistributedLoad(IFLoading lusasBarDistributedLoad,
IEnumerable <IFAssignment> lusasAssignments, Dictionary <string, Bar> bars)
{
IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset();
Loadcase loadcase = ToLoadcase(assignedLoadcase);
IEnumerable <Bar> assignedBars = GetLineAssignments(lusasAssignments, bars);
Vector startForceVector = new Vector
{
X = lusasBarDistributedLoad.getValue("startpx"),
Y = lusasBarDistributedLoad.getValue("startpy"),
Z = lusasBarDistributedLoad.getValue("startpz")
};
Vector endForceVector = new Vector
{
X = lusasBarDistributedLoad.getValue("endpx"),
Y = lusasBarDistributedLoad.getValue("endpy"),
Z = lusasBarDistributedLoad.getValue("endpz")
};
Vector startMomentVector = new Vector
{
X = lusasBarDistributedLoad.getValue("startmx"),
Y = lusasBarDistributedLoad.getValue("startmy"),
Z = lusasBarDistributedLoad.getValue("startmz")
};
Vector endMomentVector = new Vector
{
X = lusasBarDistributedLoad.getValue("endmx"),
Y = lusasBarDistributedLoad.getValue("endmy"),
Z = lusasBarDistributedLoad.getValue("endmz")
};
double startPosition = lusasBarDistributedLoad.getValue("startDistance");
double endPosition = lusasBarDistributedLoad.getValue("endDistance");
bool relativePositions = lusasBarDistributedLoad.getValue("Type") == "Parametric" ? true : false;
LoadAxis axis = LoadAxis.Global;
bool projected = false;
BH.Engine.Base.Compute.RecordWarning("All BarVaryingDistributedLoads pulled from Lusas are assumed to be in global coordinates and to not be projected.");
BarVaryingDistributedLoad barVarDistributedLoad;
barVarDistributedLoad = Engine.Structure.Create.BarVaryingDistributedLoad(
loadcase,
assignedBars,
startPosition,
startForceVector,
startMomentVector,
endPosition,
endForceVector,
endMomentVector,
relativePositions,
axis,
projected,
GetName(lusasBarDistributedLoad));
if (barVarDistributedLoad == null)
{
return(null);
}
int adapterNameId = lusasBarDistributedLoad.getID();
barVarDistributedLoad.SetAdapterId(typeof(LusasId), adapterNameId);
return(barVarDistributedLoad);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private List <IFLoadingBeamDistributed> CreateBarDistributedLoad(
BarVaryingDistributedLoad barDistributedLoad, object[] lusasLines)
{
List <IFLoadingBeamDistributed> lusasBarDistributedLoads = new List <IFLoadingBeamDistributed>();
IFAssignment lusasAssignment = m_LusasApplication.assignment();
IFLoadcase assignedLoadcase = (IFLoadcase)d_LusasData.getLoadset(barDistributedLoad.Loadcase.AdapterId <int>(typeof(LusasId)));
Engine.Base.Compute.RecordWarning(
barDistributedLoad.GetType().ToString() + " uses parametric distances in the Lusas_Toolkit"
);
List <double> valuesAtA = new List <double> {
barDistributedLoad.ForceAtStart.X, barDistributedLoad.ForceAtStart.Y, barDistributedLoad.ForceAtStart.Z,
barDistributedLoad.MomentAtStart.X, barDistributedLoad.MomentAtStart.Y, barDistributedLoad.MomentAtStart.Z
};
List <double> valuesAtB = new List <double> {
barDistributedLoad.ForceAtEnd.X, barDistributedLoad.ForceAtEnd.Y, barDistributedLoad.ForceAtEnd.Z,
barDistributedLoad.MomentAtEnd.X, barDistributedLoad.MomentAtEnd.Y, barDistributedLoad.MomentAtEnd.Z
};
List <string> keys = new List <string>()
{
"FX", "FY", "FZ", "MX", "MY", "MZ"
};
List <int> ids = new List <int>();
string positioning = barDistributedLoad.RelativePositions ? "parametric" : "actual";
string axis;
if (barDistributedLoad.Projected)
{
axis = "projected";
if (barDistributedLoad.RelativePositions)
{
Engine.Base.Compute.RecordError("Projected loads with parametric distances are not supported in Lusas.");
return(null);
}
}
else
{
axis = barDistributedLoad.Axis == LoadAxis.Global ? "global" : "local";
}
for (int i = 0; i < valuesAtA.Count(); i++)
{
double valueAtA = valuesAtA[i];
double valueAtB = valuesAtB[i];
if ((valueAtA != 0) || (valueAtB != 0))
{
IFLoadingBeamDistributed lusasBarDistributedLoad;
if (d_LusasData.existsAttribute("Loading", barDistributedLoad.Name + keys[i]))
{
lusasBarDistributedLoad = (IFLoadingBeamDistributed)d_LusasData.getAttribute("Loading", barDistributedLoad.Name + keys[i]);
lusasBarDistributedLoads.Add(lusasBarDistributedLoad);
}
else
{
lusasBarDistributedLoad = d_LusasData.createLoadingBeamDistributed(barDistributedLoad.Name + keys[i]);
lusasBarDistributedLoad.setBeamDistributed(positioning, axis, "beam");
switch (keys[i])
{
case "FX":
lusasBarDistributedLoad.addRow(
barDistributedLoad.StartPosition, valueAtA, 0, 0, 0, 0, 0,
barDistributedLoad.EndPosition, valueAtB, 0, 0, 0, 0, 0);
lusasBarDistributedLoads.Add(lusasBarDistributedLoad);
lusasAssignment.setLoadset(assignedLoadcase);
lusasBarDistributedLoad.assignTo(lusasLines, lusasAssignment);
break;
case "FY":
lusasBarDistributedLoad.addRow(
barDistributedLoad.StartPosition, 0, valueAtA, 0, 0, 0, 0,
barDistributedLoad.EndPosition, 0, valueAtB, 0, 0, 0, 0);
lusasBarDistributedLoads.Add(lusasBarDistributedLoad);
lusasAssignment.setLoadset(assignedLoadcase);
lusasBarDistributedLoad.assignTo(lusasLines, lusasAssignment);
break;
case "FZ":
lusasBarDistributedLoad.addRow(
barDistributedLoad.StartPosition, 0, 0, valueAtA, 0, 0, 0,
barDistributedLoad.EndPosition, 0, 0, valueAtB, 0, 0, 0);
lusasBarDistributedLoads.Add(lusasBarDistributedLoad);
lusasAssignment.setLoadset(assignedLoadcase);
lusasBarDistributedLoad.assignTo(lusasLines, lusasAssignment);
break;
case "MX":
lusasBarDistributedLoad.addRow(
barDistributedLoad.StartPosition, 0, 0, 0, valueAtA, 0, 0,
barDistributedLoad.EndPosition, 0, 0, 0, valueAtB, 0, 0);
lusasBarDistributedLoads.Add(lusasBarDistributedLoad);
lusasAssignment.setLoadset(assignedLoadcase);
if (barDistributedLoad.Projected || barDistributedLoad.Axis == LoadAxis.Global)
{
Engine.Base.Compute.RecordWarning("Lusas does not support internal distributed moments in the global axis or as projected loads.");
}
lusasBarDistributedLoad.assignTo(lusasLines, lusasAssignment);
break;
case "MY":
lusasBarDistributedLoad.addRow(
barDistributedLoad.StartPosition, 0, 0, 0, 0, valueAtA, 0,
barDistributedLoad.EndPosition, 0, 0, 0, 0, valueAtB, 0);
lusasBarDistributedLoads.Add(lusasBarDistributedLoad);
lusasAssignment.setLoadset(assignedLoadcase);
lusasBarDistributedLoad.assignTo(lusasLines, lusasAssignment);
break;
case "MZ":
lusasBarDistributedLoad.addRow(
barDistributedLoad.StartPosition, 0, 0, 0, 0, 0, valueAtA,
barDistributedLoad.EndPosition, 0, 0, 0, 0, 0, valueAtB);
lusasBarDistributedLoads.Add(lusasBarDistributedLoad);
lusasAssignment.setLoadset(assignedLoadcase);
lusasBarDistributedLoad.assignTo(lusasLines, lusasAssignment);
break;
}
lusasBarDistributedLoads.Add(lusasBarDistributedLoad);
ids.Add(lusasBarDistributedLoad.getID());
}
}
}
barDistributedLoad.SetAdapterId(typeof(LusasId), ids);
return(lusasBarDistributedLoads);
}
/***************************************************/
/**** Private helper methods ****/
/***************************************************/
private bool Analyse(IEnumerable <object> cases = null)
{
d_LusasData.closeAllResults();
d_LusasData.updateMesh();
string filename = d_LusasData.getDBFilename();
if (filename == "")
{
Engine.Base.Compute.RecordError("Model has not been saved with a filename, please SaveAs with a filename");
return(false);
}
d_LusasData.save();
IFLusasRunOptionsObj solverOptions = m_LusasApplication.solverOptions();
IFTabulateDataObj solverExport = m_LusasApplication.solverExport();
solverOptions.setAllDefaults();
solverExport.setFilename("%DBFolder%\\%ModelName%~Analysis 1.dat");
solverExport.setAnalysis("Analysis 1");
if (cases == null || cases.Count() == 0)
{
solverExport.setSolveAllLoadcases(true);
}
else
{
//Disable setSolveAllLoadcases, this overrides the setDoSolve on individual loadcases
solverExport.setSolveAllLoadcases(false);
List <string> names = new List <string>();
//Select provided cases
foreach (object item in cases)
{
string name;
if (item == null)
{
continue;
}
if (item is string)
{
name = item as string;
}
else if (item is ICase)
{
name = (item as ICase).Name;
}
else
{
Engine.Base.Compute.RecordWarning("Can not set up cases for running of type " + item.GetType().Name + ". Item " + item.ToString() + " will be ignored. Please provide case names or BHoM cases to be run");
continue;
}
names.Add(name);
}
object[] loadcases = d_LusasData.getLoadsets("loadcase", "all");
for (int i = 0; i < loadcases.Count(); i++)
{
IFLoadcase loadcase = (IFLoadcase)loadcases[i];
if (names.Contains(loadcase.getName()))
{
loadcase.setDoSolve(true);
}
else
{
loadcase.setDoSolve(false);
}
}
}
int exportError = d_LusasData.exportSolver(solverExport, solverOptions);
//Did any calls to exportSolver and solve produce errors?
bool exportErrors = false;
bool solveErrors = false;
//Any non-zero value for solveError or ExportError indicates an error
int solveError;
if (exportError != 0)
{
exportErrors = true;
}
else
{
solveError = m_LusasApplication.solve("%DBFolder%\\%ModelName%~Analysis 1.dat", solverOptions);
if (solveError != 0)
{
solveErrors = true;
}
m_LusasApplication.fileOpen("%PerMachineAppDataPlatform%\\config\\AfterSolve");
m_LusasApplication.scanout("%DBFolder%\\%ModelName%~Analysis 1.out");
}
m_LusasApplication.processSolveErrors(exportErrors, solveErrors);
d_LusasData.openResults("%DBFolder%\\%ModelName%~Analysis 1.mys", "Analysis 1", false, 0, false, false);
return(!(exportErrors & solveErrors));
}
private IFLoadingTemperature CreateTemperatureLoad(string name,
double temperatureChange, object[] lusasGeometry, IFLoadcase assignedLoadcase)
{
IFLoadingTemperature lusasTemperatureLoad;
if (d_LusasData.existsAttribute("Loading", name))
{
lusasTemperatureLoad = (IFLoadingTemperature)d_LusasData.getAttributes("Loading", name);
}
else
{
lusasTemperatureLoad = d_LusasData.createLoadingTemperature(name);
lusasTemperatureLoad.setValue("T0", 0);
lusasTemperatureLoad.setValue("T", temperatureChange);
}
IFAssignment lusasAssignment = m_LusasApplication.assignment();
lusasAssignment.setLoadset(assignedLoadcase);
lusasTemperatureLoad.assignTo(lusasGeometry, lusasAssignment);
return(lusasTemperatureLoad);
}
