public static void CreateModel(Karamba.Models.Model kModel)
{
if (RModel != null)
{
Node[] rNodes = Nodes(kModel.nodes);
NodalSupport[] rSupports = Supports(kModel.supports);
Material[] rMaterials = Materials(kModel.materials);
CrossSection[] rCrossSections = CrossSections(kModel.crosecs, kModel);
Tuple <Member[], Dlubal.RFEM5.Line[]> vali = Members(kModel.elems);
Member[] rMembers = vali.Item1;
Dlubal.RFEM5.Line[] rLines = vali.Item2;
LoadCase[] lCases = LoadCases(kModel);
MemberLoad[] rMemberLoads = MemberLoads(kModel.eloads);
NodalLoad[] rNodalLoads = NodalLoads(kModel.ploads);
MemberHinge[] rMemberHinges = MemberHinges(kModel.joints);
//Get active RFEM5 application
try
{
IModelData rData = RModel.GetModelData();
ILoads rLoads = RModel.GetLoads();
//Cleans the model and load data data
rData.PrepareModification();
rData.Clean();
rData.FinishModification();
rLoads.PrepareModification();
rLoads.Clean();
rLoads.FinishModification();
//Model elements
rData.PrepareModification();
rData.SetNodes(rNodes);
rData.SetNodalSupports(rSupports);
rData.SetMaterials(rMaterials);
rData.SetCrossSections(rCrossSections);
rData.SetMemberHinges(rMemberHinges);
rData.SetLines(rLines);
rData.SetMembers(rMembers);
rData.FinishModification();
//Load cases
rLoads.PrepareModification();
rLoads.SetLoadCases(lCases);
rLoads.FinishModification();
//Loads
setRFEMmemberLoads(rLoads, rMemberLoads);
setRFEMnodalLoads(rLoads, rNodalLoads);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, ex.Source, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
//Sets all the member loads to RFEM (Only uniform distributed load is implemented
private static void setRFEMmemberLoads(ILoads rLoads, MemberLoad[] rMemberLoads)
{
Dictionary <int, List <MemberLoad> > loads = new Dictionary <int, List <MemberLoad> >();
foreach (MemberLoad rMemberLoad in rMemberLoads)
{
if (!loads.ContainsKey(int.Parse(rMemberLoad.Comment)))
{
List <MemberLoad> nLoad = new List <MemberLoad>();
MemberLoad a = rMemberLoad;
a.Comment = "";
nLoad.Add(a);
loads[int.Parse(rMemberLoad.Comment)] = nLoad;
}
else
{
MemberLoad a = rMemberLoad;
a.Comment = "";
loads[int.Parse(rMemberLoad.Comment)].Add(a);
}
}
foreach (int n in loads.Keys)
{
ILoadCase lCase = rLoads.GetLoadCase(n, ItemAt.AtNo);
lCase.PrepareModification();
lCase.SetMemberLoads(loads[n].ToArray());
lCase.FinishModification();
}
}
private void duStuff(ILoads rLoads, double mult, int i, ref ErrorInfo[] err, ref ICalculation calc)
{
ILoadCase lCase = rLoads.GetLoadCase(1, ItemAt.AtNo);
AnalysisParameters param = new AnalysisParameters();
param.ModifyLoadingByFactor = true;
param.LoadingFactor = mult;
param.Method = AnalysisMethodType.SecondOrder;
//Loads
//lc.PrepareModification();
rLoads.PrepareModification();
try
{
lCase.SetAnalysisParameters(ref param);
}
finally
{
rLoads.FinishModification();
//lc.FinishModification();
lCase = null;
}
err = calc.Calculate(LoadingType.LoadCaseType, 1);
if (err.Length == 0)
{
IResults res = calc.GetResultsInFeNodes(LoadingType.LoadCaseType, 1);
MaximumResults max = res.GetMaximum();
Point3D point = max.Displacement;
double value = Math.Sqrt(Math.Pow(point.X, 2) + Math.Pow(point.Y, 2) + Math.Pow(point.Z, 2));
chart1.Series["deflection"].Points.AddXY(i, value);
}
}
public static void GetAllCalculatedResults(this ILoads loads, ref List <string> lCasesAndCombos, ref ICalculation results, ref int countCases, ref int countCombos, ref int countResultCombos, ref List <string> msg)
{
/// Get results just of calculated load cases and combos and add names to dropdown menu
lCasesAndCombos = new List <string>();
countCases = 0;
countCombos = 0;
countResultCombos = 0;
// Load cases
foreach (var lc in loads.GetLoadCases())
{
var loading = lc.Loading;
if (loads.HasLoadingResults(loading))
{
lCasesAndCombos.Add($"LoadCase {loading.No}");
var errors = results.Calculate(loading.Type, loading.No);
if (errors != null)
{
msg.AddRange(errors.Select(x => x.Description));
}
countCases++;
}
}
// Load combos
foreach (var lc in loads.GetLoadCombinations())
{
var loading = lc.Loading;
if (loads.HasLoadingResults(loading))
{
lCasesAndCombos.Add($"LoadCombo {loading.No}");
var errors = results.Calculate(loading.Type, loading.No);
if (errors != null)
{
msg.AddRange(errors.Select(x => x.Description));
}
}
countCombos++;
}
// Result combos
foreach (var lc in loads.GetResultCombinations())
{
var loading = lc.Loading;
if (loads.HasLoadingResults(loading))
{
lCasesAndCombos.Add($"ResultCombo {loading.No}");
var errors = results.Calculate(loading.Type, loading.No);
if (errors != null)
{
msg.AddRange(errors.Select(x => x.Description));
}
}
countResultCombos++;
}
}
public static void GetLoadCasesAndCombos(this ILoads loads, ref List <string> lCasesAndCombos, ref int countCases, ref int countCombos, ref int countRcombos)
{
var lCases = new List <string>();
var lCombos = new List <string>();
var rCombos = new List <string>();
lCases = loads.GetLoadCases().Select(x => "LoadCase " + x.Loading.No.ToString()).ToList();
countCases = lCases.Count;
lCombos = loads.GetLoadCombinations().Select(x => "LoadCombo " + x.Loading.No.ToString()).ToList();
countCombos = lCombos.Count;
rCombos = loads.GetResultCombinations().Select(x => "ResultCombo " + x.Loading.No.ToString()).ToList();
countRcombos = rCombos.Count;
lCasesAndCombos = new List <string>();
lCasesAndCombos.AddRange(lCases);
lCasesAndCombos.AddRange(lCombos);
lCasesAndCombos.AddRange(rCombos);
}
public static List <string> GetLoadCasesAndCombos(this ILoads loads, ref int countCases, ref int countCombos, ref int countRcombos)
{
var lCasesAndCombos = new List <string>();
countCases = 0;
countCombos = 0;
countRcombos = 0;
// Load cases
foreach (var lc in loads.GetLoadCases())
{
var loading = lc.Loading;
if (loads.HasLoadingResults(loading))
{
lCasesAndCombos.Add($"LoadCase {loading.No}");
countCases++;
}
}
// Load combos
foreach (var lc in loads.GetLoadCombinations())
{
var loading = lc.Loading;
if (loads.HasLoadingResults(loading))
{
lCasesAndCombos.Add($"LoadCombo {loading.No}");
}
countCombos++;
}
// Result combos
foreach (var lc in loads.GetResultCombinations())
{
var loading = lc.Loading;
if (loads.HasLoadingResults(loading))
{
lCasesAndCombos.Add($"ResultCombo {loading.No}");
}
countRcombos++;
}
return(lCasesAndCombos);
}
public static List <Tuple <int, Vector3d, Vector3d> > GetMemberIternalForces(List <int> loadCases, LoadingType loadingType, int memberNumber)
{
OpenConnection();
List <Tuple <int, Vector3d, Vector3d> > results = new List <Tuple <int, Vector3d, Vector3d> >();
try
{
ICalculation calc = RModel.GetCalculation();
IModelData data = RModel.GetModelData();
ILoads loads = RModel.GetLoads();
LoadCombination[] lc = loads.GetLoadCombinations();
foreach (int loadcase in loadCases)
{
try
{
IResults res = calc.GetResultsInFeNodes(loadingType, loadcase);
MemberForces[] mf = res.GetMemberInternalForces(memberNumber, ItemAt.AtNo, true);
Vector3d startForces = new Vector3d(mf[0].Forces.X, mf[0].Moments.Y, mf[0].Moments.Z);
Vector3d endForces = new Vector3d(mf[mf.Length - 1].Forces.X, mf[mf.Length - 1].Moments.Y, mf[mf.Length - 1].Moments.Z);
results.Add(Tuple.Create(loadcase, startForces, endForces));
}
catch { continue; }
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, ex.Source, MessageBoxButtons.OK, MessageBoxIcon.Error);
//Cleans Garbage collector for releasing all COM interfaces and objects
System.GC.Collect();
System.GC.WaitForPendingFinalizers();
}
finally
{
CloseConnection();
}
return(results);
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object can be used to retrieve data from input parameters and
/// to store data in output parameters.</param>
protected override void SolveInstance(IGH_DataAccess DA, EvaluationUnit unit)
{
var run = false;
var ghNodes = new List <GH_RFEM>();
var ghLines = new List <GH_RFEM>();
var ghMembers = new List <GH_RFEM>();
var ghSfcs = new List <GH_RFEM>();
var ghOps = new List <GH_RFEM>();
var ghSupsP = new List <GH_RFEM>();
var ghSupsL = new List <GH_RFEM>();
var ghSupsS = new List <GH_RFEM>();
var ghMHs = new List <GH_RFEM>();
var ghLHs = new List <GH_RFEM>();
var ghCSs = new List <GH_RFEM>();
var ghMats = new List <GH_RFEM>();
var ghNodalLoads = new List <GH_RFEM>();
var ghLineLoads = new List <GH_RFEM>();
var ghMemberLoads = new List <GH_RFEM>();
var ghSurfaceLoads = new List <GH_RFEM>();
var ghPolyLoads = new List <GH_RFEM>();
var ghLoadCases = new List <GH_RFEM>();
var ghLoadCombos = new List <GH_RFEM>();
var ghResultCombos = new List <GH_RFEM>();
var modelName = "";
IModel model = null;
IModelData data = null;
ILoads loads = null;
var errorMsg = new List <string>();
DA.GetData(0, ref run);
if (run)
{
Component_SetData.ClearOutput(ref nodesNo, ref linesNo, ref membersNo, ref srfcNo, ref opNo, ref nodSupNo, ref lineSupNo, ref sfcSupNo,
ref memberHingeNo, ref lineHingeNo, ref croSecNo, ref matNo, ref nodalLoadNo, ref lineLoadNo, ref memberLoadNo, ref surfaceLoadNo,
ref polyLoadNo, ref loadcaseNo, ref loadcomboNo, ref resultcomboNo);
if (!DA.GetData(modelDataCount3 + 1, ref modelName))
{
Component_GetData.ConnectRFEM(ref model, ref data);
}
else
{
Component_GetData.ConnectRFEM(modelName, ref model, ref data);
}
try
{
// Set data
data.PrepareModification();
if (DA.GetDataList(12, ghMats))
{
data.SetRFMaterials(ghMats, ref matNo, ref errorMsg);
}
if (DA.GetDataList(11, ghCSs))
{
data.SetRFCroSecs(ghCSs, ref croSecNo, ref errorMsg);
}
if (DA.GetDataList(9, ghMHs))
{
data.SetRFMemberHinges(ghMHs, ref memberHingeNo, ref errorMsg);
}
if (DA.GetDataList(1, ghNodes))
{
data.SetRFNodes(ghNodes, ref nodesNo, ref errorMsg);
}
if (DA.GetDataList(2, ghLines))
{
data.SetRFLines(ghLines, ref linesNo, ref errorMsg);
}
if (DA.GetDataList(3, ghMembers))
{
data.SetRFMembers(ghMembers, ref membersNo, ref errorMsg);
}
if (DA.GetDataList(4, ghSfcs))
{
data.SetRFSurfaces(ghSfcs, ref srfcNo, ref errorMsg);
}
if (DA.GetDataList(5, ghOps))
{
data.SetRFOpenings(ghOps, ref opNo, ref errorMsg);
}
if (DA.GetDataList(6, ghSupsP))
{
data.SetRFSupportsP(ghSupsP, ref nodSupNo, ref errorMsg);
}
if (DA.GetDataList(7, ghSupsL))
{
data.SetRFSupportsL(ghSupsL, ref lineSupNo, ref errorMsg);
}
if (DA.GetDataList(8, ghSupsS))
{
data.SetRFSupportsS(ghSupsS, ref sfcSupNo, ref errorMsg);
}
if (DA.GetDataList(10, ghLHs))
{
data.SetRFLineHinges(ghLHs, ref lineHingeNo, ref errorMsg);
}
data.FinishModification();
// Set Load Cases and Combos
if (DA.GetDataList(modelDataCount2 + 1, ghLoadCases))
{
if (loads == null)
{
Component_GetData.GetLoadsFromRFEM(model, ref loads);
}
data.SetRFLoadCases(loads, ghLoadCases, ref loadcaseNo, ref errorMsg);
}
if (DA.GetDataList(modelDataCount2 + 2, ghLoadCombos))
{
if (loads == null)
{
Component_GetData.GetLoadsFromRFEM(model, ref loads);
}
data.SetRFLoadCombos(loads, ghLoadCombos, ref loadcomboNo, ref errorMsg);
}
if (DA.GetDataList(modelDataCount2 + 3, ghResultCombos))
{
if (loads == null)
{
Component_GetData.GetLoadsFromRFEM(model, ref loads);
}
data.SetRFResultCombos(loads, ghResultCombos, ref resultcomboNo, ref errorMsg);
}
// Set Loads
if (DA.GetDataList(modelDataCount + 1, ghNodalLoads))
{
if (loads == null)
{
Component_GetData.GetLoadsFromRFEM(model, ref loads);
}
data.SetRFNodalLoads(loads, ghNodalLoads, ref nodalLoadNo, ref errorMsg);
}
if (DA.GetDataList(modelDataCount + 2, ghLineLoads))
{
if (loads == null)
{
Component_GetData.GetLoadsFromRFEM(model, ref loads);
}
data.SetRFLineLoads(loads, ghLineLoads, ref lineLoadNo, ref errorMsg);
}
if (DA.GetDataList(modelDataCount + 3, ghMemberLoads))
{
if (loads == null)
{
Component_GetData.GetLoadsFromRFEM(model, ref loads);
}
data.SetRFMemberLoads(loads, ghMemberLoads, ref memberLoadNo, ref errorMsg);
}
if (DA.GetDataList(modelDataCount + 4, ghSurfaceLoads))
{
if (loads == null)
{
Component_GetData.GetLoadsFromRFEM(model, ref loads);
}
data.SetRFSurfaceLoads(loads, ghSurfaceLoads, ref surfaceLoadNo, ref errorMsg);
}
if (DA.GetDataList(modelDataCount + 5, ghPolyLoads))
{
if (loads == null)
{
Component_GetData.GetLoadsFromRFEM(model, ref loads);
}
data.SetRFFreePolygonLoads(loads, ghPolyLoads, ref polyLoadNo, ref errorMsg);
}
}
catch (Exception ex)
{
Component_SetData.ClearOutput(ref nodesNo, ref linesNo, ref membersNo, ref srfcNo, ref opNo, ref nodSupNo, ref lineSupNo, ref sfcSupNo,
ref memberHingeNo, ref lineHingeNo, ref croSecNo, ref matNo, ref nodalLoadNo, ref lineLoadNo, ref memberLoadNo, ref surfaceLoadNo,
ref polyLoadNo, ref loadcaseNo, ref loadcomboNo, ref resultcomboNo);
Component_GetData.DisconnectRFEM(ref model, ref data);
throw ex;
}
Component_GetData.DisconnectRFEM(ref model, ref data);
}
// Assign Output
DA.SetDataList(0, nodesNo);
DA.SetDataList(1, linesNo);
DA.SetDataList(2, membersNo);
DA.SetDataList(3, srfcNo);
DA.SetDataList(4, opNo);
DA.SetDataList(5, nodSupNo);
DA.SetDataList(6, lineSupNo);
DA.SetDataList(7, sfcSupNo);
DA.SetDataList(8, memberHingeNo);
DA.SetDataList(9, lineHingeNo);
DA.SetDataList(10, croSecNo);
DA.SetDataList(11, matNo);
DA.SetDataList(12, nodalLoadNo);
DA.SetDataList(13, lineLoadNo);
DA.SetDataList(14, memberLoadNo);
DA.SetDataList(15, surfaceLoadNo);
DA.SetDataList(16, polyLoadNo);
DA.SetDataList(17, loadcaseNo);
DA.SetDataList(18, loadcomboNo);
DA.SetDataList(19, resultcomboNo);
if (errorMsg.Count != 0)
{
//errorMsg.Add("List item index may be one unit lower than object number");
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, String.Join(System.Environment.NewLine, errorMsg.ToArray()));
}
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object can be used to retrieve data from input parameters and
/// to store data in output parameters.</param>
protected override void SolveInstance(IGH_DataAccess DA, EvaluationUnit unit)
{
// RFEM variables
var modelName = "";
IModel model = null;
IModelData data = null;
ILoads loads = null;
// Assign GH Input
bool run = false;
var scale = 0.0;
string iLoadCase = "";
DA.GetData(0, ref run);
DA.GetData(1, ref scale);
// Do stuff
if (run)
{
msg = new List <string>();
if (!DA.GetData(5, ref modelName))
{
Component_GetData.ConnectRFEM(ref model, ref data);
}
else
{
Component_GetData.ConnectRFEM(modelName, ref model, ref data);
}
_saveddata = data;
try
{
// Get deformtions
_resetLC = true;
// Get loads
Component_GetData.GetLoadsFromRFEM(model, ref loads);
// Update load cases and combos to display in dropdown menu
_results = model.GetCalculation();
// Get load cases and combos to
var newLoadCasesAndCombos = new List <string>();
newLoadCasesAndCombos = loads.GetLoadCasesAndCombos(ref _countCases, ref _countCombos, ref _countRcombos);
if (_lCasesAndCombos == null || _lCasesAndCombos.Count == 0 || !_lCasesAndCombos.Equals(newLoadCasesAndCombos))
{
_lCasesAndCombos = newLoadCasesAndCombos;
_loadDropLastValue = 0; // reset dropdown menus if run
_resultDropLastValue = 0;
_lastLoadCase = "";
_lastType = 0;
_restoreDropDown = true;
}
// Get deformed shape?
if (_deformationsCheck.Active)
{
_deformation_results = true;
// Get members
_rfMembers = Component_GetData.GetRFMembers(data.GetMembers().ToList(), data);
// Get Fe Meshes from RFEM
_rfemMesh = _results.GetFeMesh();
_feMeshes = CreateFEMeshes(ref msg);
}
else
{
_deformation_results = false;
}
// Disconnect RFEM
Component_GetData.DisconnectRFEM(ref model, ref data);
// Results are displayed just when the button is set to 0 - if no LC is provided
var dummyLC = "";
if (!DA.GetData(2, ref dummyLC))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Set run to false to display results");
return;
}
}
catch (Exception ex)
{
Component_GetData.DisconnectRFEM(ref model, ref data);
// Clear output!!!
_saveddata = null;
_rfemMesh = null;
_results = null;
_lcresults = null;
outResults = null;
_feMeshes.Clear();
_meshdisplacements.Clear();
_meshdisplacementsByType.Clear();
_deformedMeshes.Clear();
_controlPoints.Clear();
_memberdisplacements.Clear();
_memberdisplacementsByType.Clear();
_deformedMembers.Clear();
_sfcNo.Clear();
_memberNo.Clear();
_deformation_results = false;
throw ex;
}
}
// do stuff
if (msg.Count == 0) // if there are no calculation errors
{
// Get Load Case Number and result type
int result_type = 0;
string result_type_name = "";
if (DA.GetData(2, ref iLoadCase))
{
if (DA.GetData(3, ref result_type))
{
if (result_type <= 0 || result_type > Enum.GetNames(typeof(ResultsValueType)).Length - 1)
{
_loadDrop.Clear();
_resulttypeDrop.Clear();
_restoreDropDown = true; // for next time
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Provide Valid Result Type.");
return;
}
result_type_name = Enum.GetName(typeof(ResultsValueType), result_type);
if (_lastLoadCase != iLoadCase || _lastType != result_type) // otherwise execution comes from change in scale and no need to reset load case
{
_resetLC = true;
}
_loadDrop.Clear();
_resulttypeDrop.Clear();
_restoreDropDown = true; // for next time
}
else
{
_loadDrop.Clear();
_resulttypeDrop.Clear();
_restoreDropDown = true; // for next time
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Provide Result Type.");
return;
}
}
else if (DA.GetData(3, ref result_type))
{
_loadDrop.Clear();
_resulttypeDrop.Clear();
_restoreDropDown = true; // for next time
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Provide Load Case or Combo.");
return;
}
else // get values from dropdown menus
{
if (_lCasesAndCombos.Count == 0)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "No results to display");
_loadDrop.Clear();
_resulttypeDrop.Clear();
return;
}
if (_restoreDropDown) // from previous execution when it was overwritten
{
updateDropDownMenu(_lCasesAndCombos);
_resetLC = true;
_restoreDropDown = false; // for next time
}
iLoadCase = _loadDrop.Items[_loadDrop.Value].name;
}
// Get results to display
// 1) Results from load case or combo for all types 2) Results for selected result type 3) Apply scale
if (_resetLC)
{
int no = Int16.Parse(iLoadCase.Split(' ')[1]);
var value = _lCasesAndCombos.IndexOf(iLoadCase);
_loadDropLastValue = value;
_lastLoadCase = iLoadCase;
if (value == -1)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, $"{iLoadCase} has no results. Provide valid load case.");
return;
}
if (value < _countCases)
{
_lcresults = _results.GetResultsInFeNodes(LoadingType.LoadCaseType, no);
}
else if (value < _countCases + _countCombos)
{
_lcresults = _results.GetResultsInFeNodes(LoadingType.LoadCombinationType, no);
}
else if (value < _countCases + _countCombos + _countRcombos)
{
_lcresults = _results.GetResultsInFeNodes(LoadingType.ResultCombinationType, no);
}
else
{
msg.Add("Load case or combo not found");
return;
}
// Get analysis results
_resultTypes = new HashSet <ResultsValueType>();
outResults = new RFResults(_lcresults, _saveddata, buttonLocal.Active, ref _resultTypes, iLoadCase,
_memberForcesCheck.Active, _surfaceForcesCheck.Active, _nodalReactionsCheck.Active,
_lineReactionsCheck.Active);
// Get deformations
if (_deformationsCheck.Active)
{
if (!_deformation_results)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Run component again to get deformation results.");
}
else
{
_meshdisplacements = GetMeshDisplacements(ref _sfcNo, ref msg);
_memberdisplacements = GetMemberDisplacements(ref _memberNo, ref msg);
_meshdisplacementsByType = GetMeshDisplacementsByType(result_type);
_memberdisplacementsByType = GetMemberDisplacementsByType(result_type);
}
}
// Update drop down menu of result types
if (result_type == 0) // if no value obtaines through overwrite
{
_resultDropLastValue = 0;
updateDropDownMenu2(_resultTypes.ToList(), ref result_type);
}
// Set _resetLC to false again
_resetLC = false;
_resetResultType = true;
}
if (_resetResultType) // when there are changes in drop down menu
{
if (result_type == 0) // if no value obtaines through overwrite
{
result_type = Int32.Parse(_resulttypeDrop.Items[_resulttypeDrop.Value].name);
}
if (_deformationsCheck.Active)
{
_meshdisplacementsByType = GetMeshDisplacementsByType(result_type);
_memberdisplacementsByType = GetMemberDisplacementsByType(result_type);
}
// Get analysis results
if (result_type > 0)
{
outResults.ResultType = ((ResultsValueType)result_type).ToString();
}
// Set _resetType to false again
_resetResultType = false;
}
_lastType = result_type;
// Check results
if (_meshdisplacements.DataCount > 0 && _meshdisplacementsByType.DataCount == 0)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, $"No surface results found for result type {((ResultsValueType)result_type).ToString()}");
}
if (_memberdisplacements.DataCount > 0 && _memberdisplacementsByType.DataCount == 0)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, $"No member results found for result type {((ResultsValueType)result_type).ToString()}");
}
// Get output
_deformedMeshes = GetDeformedMeshes(scale, ref msg);
_deformedMembers = GetDeformedMembers(scale, ref msg);
// Output calculation results
DA.SetData(0, outResults);
// Assign GH Output
DA.SetDataList(1, _deformedMembers);
DA.SetDataList(2, _memberNo);
DA.SetDataList(3, _deformedMeshes);
DA.SetDataList(4, _sfcNo);
}
if (msg.Count > 0)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, String.Join(System.Environment.NewLine, msg.ToArray()));
}
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object can be used to retrieve data from input parameters and
/// to store data in output parameters.</param>
protected override void SolveInstance(IGH_DataAccess DA, EvaluationUnit unit)
{
var run = false;
var ghNodes = new List <GH_RFEM>();
var ghLines = new List <GH_RFEM>();
var ghMembers = new List <GH_RFEM>();
var ghSfcs = new List <GH_RFEM>();
var ghOps = new List <GH_RFEM>();
var ghSupsP = new List <GH_RFEM>();
var ghSupsL = new List <GH_RFEM>();
var ghLHs = new List <GH_RFEM>();
var ghCSs = new List <GH_RFEM>();
var ghMats = new List <GH_RFEM>();
var ghNodalLoads = new List <GH_RFEM>();
var modelName = "";
IModel model = null;
IModelData data = null;
ILoads loads = null;
DA.GetData(modelDataCount - 1, ref run);
if (run)
{
Component_SetData.ClearOutput(ref nodesNo, ref linesNo, ref membersNo, ref srfcNo, ref opNo, ref nodSupNo, ref lineSupNo,
ref lineHingeNo, ref croSecNo, ref matNo, ref nodalLoadNo);
if (!DA.GetData(modelDataCount + modelDataCount2, ref modelName))
{
Component_GetData.ConnectRFEM(ref model, ref data);
}
else
{
Component_GetData.ConnectRFEM(modelName, ref model, ref data);
}
try
{
// Set data
data.PrepareModification();
if (DA.GetDataList(9, ghMats))
{
data.SetRFMaterials(ghMats, ref matNo);
}
if (DA.GetDataList(8, ghCSs))
{
data.SetRFCroSecs(ghCSs, ref croSecNo);
}
if (DA.GetDataList(0, ghNodes))
{
data.SetRFNodes(ghNodes, ref nodesNo);
}
if (DA.GetDataList(1, ghLines))
{
data.SetRFLines(ghLines, ref linesNo);
}
if (DA.GetDataList(2, ghMembers))
{
data.SetRFMembers(ghMembers, ref membersNo);
}
if (DA.GetDataList(3, ghSfcs))
{
data.SetRFSurfaces(ghSfcs, ref srfcNo);
}
if (DA.GetDataList(4, ghOps))
{
data.SetRFOpenings(ghOps, ref opNo);
}
if (DA.GetDataList(5, ghSupsP))
{
data.SetRFSupportsP(ghSupsP, ref nodSupNo);
}
if (DA.GetDataList(6, ghSupsL))
{
data.SetRFSupportsL(ghSupsL, ref lineSupNo);
}
if (DA.GetDataList(7, ghLHs))
{
data.SetRFLineHinges(ghLHs, ref lineHingeNo);
}
data.FinishModification();
// Set Loads
if (DA.GetDataList(modelDataCount, ghNodalLoads))
{
Component_GetData.GetLoadsFromRFEM(model, ref loads);
data.SetRFNodalLoads(loads, ghNodalLoads, ref nodalLoadNo);
}
}
catch (Exception ex)
{
Component_SetData.ClearOutput(ref nodesNo, ref linesNo, ref membersNo, ref srfcNo, ref opNo, ref nodSupNo, ref lineSupNo,
ref lineHingeNo, ref croSecNo, ref matNo, ref nodalLoadNo);
Component_GetData.DisconnectRFEM(ref model, ref data);
throw ex;
}
Component_GetData.DisconnectRFEM(ref model, ref data);
}
// Assign Output
DA.SetDataList(0, nodesNo);
DA.SetDataList(1, linesNo);
DA.SetDataList(2, membersNo);
DA.SetDataList(3, srfcNo);
DA.SetDataList(4, opNo);
DA.SetDataList(5, nodSupNo);
DA.SetDataList(6, lineSupNo);
DA.SetDataList(7, lineHingeNo);
DA.SetDataList(8, croSecNo);
DA.SetDataList(9, matNo);
DA.SetDataList(10, nodalLoadNo);
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object can be used to retrieve data from input parameters and
/// to store data in output parameters.</param>
protected override void SolveInstance(IGH_DataAccess DA, EvaluationUnit unit)
{
// Input counter
modelDataCount1 = 1 + modelDataCount2;
// RFEM variables
var modelName = "";
IModel model = null;
IModelData data = null;
ILoads loads = null;
// Output message
var msg = new List <string>();
// Assign GH Input
bool getnodes = false;
bool getlines = false;
bool getmembers = false;
bool getsurfaces = false;
bool getopenings = false;
bool getsupportsP = false;
bool getsupportsL = false;
bool getsupportsS = false;
bool getMemberHinges = false;
bool getLineHinges = false;
bool getCroSecs = false;
bool getMaterials = false;
bool getNodalLoads = false;
bool getLineLoads = false;
bool getMemberLoads = false;
bool getSurfaceLoads = false;
bool getPolyLoads = false;
bool getLoadCases = false;
bool getLoadCombos = false;
bool getResultCombos = false;
bool run = false;
var ghFilters = new List <GH_RFFilter>();
var inFilters = new List <RFFilter>();
DA.GetData(0, ref run);
DA.GetData(1, ref getnodes);
DA.GetData(2, ref getlines);
DA.GetData(3, ref getmembers);
DA.GetData(4, ref getsurfaces);
DA.GetData(5, ref getopenings);
DA.GetData(6, ref getsupportsP);
DA.GetData(7, ref getsupportsL);
DA.GetData(8, ref getsupportsS);
DA.GetData(9, ref getMemberHinges);
DA.GetData(10, ref getLineHinges);
DA.GetData(11, ref getCroSecs);
DA.GetData(12, ref getMaterials);
DA.GetData(13, ref getNodalLoads);
DA.GetData(14, ref getLineLoads);
DA.GetData(15, ref getMemberLoads);
DA.GetData(16, ref getSurfaceLoads);
DA.GetData(17, ref getPolyLoads);
DA.GetData(18, ref getLoadCases);
DA.GetData(19, ref getLoadCombos);
DA.GetData(20, ref getResultCombos);
if (DA.GetDataList(modelDataCount3 + 1, ghFilters))
{
inFilters = ghFilters.Select(x => x.Value).ToList();
}
// Do stuff
if (run)
{
if (!DA.GetData(modelDataCount3 + 2, ref modelName))
{
Component_GetData.ConnectRFEM(ref model, ref data);
}
else
{
Component_GetData.ConnectRFEM(modelName, ref model, ref data);
}
Component_GetData.ClearOutput(ref rfNodes, ref rfLines, ref rfMembers, ref rfSurfaces, ref rfOpenings,
ref rfSupportsP, ref rfSupportsL, ref rfSupportsS, ref rfLineHinges, ref rfCroSecs, ref rfMaterials, ref rfNodalLoads,
ref rfLineLoads, ref rfMemberLoads, ref rfSurfaceLoads, ref rfPolyLoads, ref rfLoadCases, ref rfLoadCombos,
ref rfResultCombos, ref rfMemberHinges);
try
{
if (getnodes)
{
var filNodes = Component_GetData.FilterNodes(data, inFilters);
rfNodes = Component_GetData.GetRFNodes(filNodes, data);
}
if (getlines)
{
var filLines = Component_GetData.FilterLines(data, inFilters);
rfLines = Component_GetData.GetRFLines(filLines, data);
}
if (getmembers)
{
var filMembers = Component_GetData.FilterMembers(data, inFilters);
rfMembers = Component_GetData.GetRFMembers(filMembers, data);
}
if (getsurfaces)
{
var filSrfcs = Component_GetData.FilterSurfaces(data, inFilters);
rfSurfaces = Component_GetData.GetRFSurfaces(filSrfcs, data);
}
if (getopenings)
{
var filOpenings = Component_GetData.FilterOpenings(data, inFilters);
rfOpenings = Component_GetData.GetRFOpenings(filOpenings, data);
}
if (getsupportsP)
{
var filSupportsP = Component_GetData.FilterSupsP(data, inFilters);
rfSupportsP = Component_GetData.GetRFSupportsP(filSupportsP, data);
}
if (getsupportsL)
{
var filSupportsL = Component_GetData.FilterSupsL(data, inFilters);
rfSupportsL = Component_GetData.GetRFSupportsL(filSupportsL, data);
}
if (getsupportsS)
{
var filSupportsS = Component_GetData.FilterSupsS(data, inFilters);
rfSupportsS = Component_GetData.GetRFSupportsS(filSupportsS, data);
}
if (getMemberHinges)
{
var filMemberHinges = Component_GetData.FilterMH(data, inFilters);
rfMemberHinges = Component_GetData.GetRFMemberHinges(filMemberHinges, data);
}
if (getLineHinges)
{
var filLineHinges = Component_GetData.FilterLH(data, inFilters);
rfLineHinges = Component_GetData.GetRFLineHinges(filLineHinges, data);
}
if (getCroSecs)
{
var filCroSecs = Component_GetData.FilterCroSecs(data, inFilters);
rfCroSecs = Component_GetData.GetRFCroSecs(filCroSecs, model, ref msg);
}
if (getMaterials)
{
var filMaterials = Component_GetData.FilterMaterials(data, inFilters);
rfMaterials = Component_GetData.GetRFMaterials(filMaterials, data);
}
//Get Loads?
if (getNodalLoads || getLineLoads || getMemberLoads || getSurfaceLoads || getPolyLoads ||
getLoadCases || getLoadCombos || getResultCombos)
{
Component_GetData.GetLoadsFromRFEM(model, ref loads);
}
if (getNodalLoads)
{
var filNodalLoads = Component_GetData.FilterNodalLoads(data, loads, inFilters);
rfNodalLoads = Component_GetData.GetRFNodalLoads(filNodalLoads, data);
}
if (getLineLoads)
{
var filLineLoads = Component_GetData.FilterLineLoads(data, loads, inFilters);
rfLineLoads = Component_GetData.GetRFLineLoads(filLineLoads, data);
}
if (getMemberLoads)
{
var filMemberLoads = Component_GetData.FilterMemberLoads(data, loads, inFilters);
rfMemberLoads = Component_GetData.GetRFMemberLoads(filMemberLoads, data);
}
if (getSurfaceLoads)
{
var filSurfaceLoads = Component_GetData.FilterSurfaceLoads(data, loads, inFilters);
rfSurfaceLoads = Component_GetData.GetRFSurfaceLoads(filSurfaceLoads, data);
}
if (getPolyLoads)
{
var filPolyLoads = Component_GetData.FilterPolyLoads(data, loads, inFilters);
rfPolyLoads = Component_GetData.GetRFPolyLoads(filPolyLoads, data);
}
if (getLoadCases)
{
var filLoadCases = Component_GetData.FilterLoadCases(data, loads, inFilters);
rfLoadCases = Component_GetData.GetRFLoadCases(filLoadCases, data);
}
if (getLoadCombos)
{
var filLoadCombos = Component_GetData.FilterLoadCombos(data, loads, inFilters);
rfLoadCombos = Component_GetData.GetRFLoadCombos(filLoadCombos, data);
}
if (getResultCombos)
{
var filResultombos = Component_GetData.FilterResultCombos(data, loads, inFilters);
rfResultCombos = Component_GetData.GetRFResultCombos(filResultombos, data);
}
}
catch (Exception ex)
{
Component_GetData.ClearOutput(ref rfNodes, ref rfLines, ref rfMembers, ref rfSurfaces, ref rfOpenings,
ref rfSupportsP, ref rfSupportsL, ref rfSupportsS, ref rfLineHinges, ref rfCroSecs, ref rfMaterials, ref rfNodalLoads,
ref rfLineLoads, ref rfMemberLoads, ref rfSurfaceLoads, ref rfPolyLoads, ref rfLoadCases, ref rfLoadCombos,
ref rfResultCombos, ref rfMemberHinges);
throw ex;
}
Component_GetData.DisconnectRFEM(ref model, ref data);
}
// Assign GH Output
DA.SetDataList(0, rfNodes);
DA.SetDataList(1, rfLines);
DA.SetDataList(2, rfMembers);
DA.SetDataList(3, rfSurfaces);
DA.SetDataList(4, rfOpenings);
DA.SetDataList(5, rfSupportsP);
DA.SetDataList(6, rfSupportsL);
DA.SetDataList(7, rfSupportsS);
DA.SetDataList(8, rfMemberHinges);
DA.SetDataList(9, rfLineHinges);
DA.SetDataList(10, rfCroSecs);
DA.SetDataList(11, rfMaterials);
DA.SetDataList(12, rfNodalLoads);
DA.SetDataList(13, rfLineLoads);
DA.SetDataList(14, rfMemberLoads);
DA.SetDataList(15, rfSurfaceLoads);
DA.SetDataList(16, rfPolyLoads);
DA.SetDataList(17, rfLoadCases);
DA.SetDataList(18, rfLoadCombos);
DA.SetDataList(19, rfResultCombos);
if (msg.Count != 0)
{
//errorMsg.Add("List item index may be one unit lower than object number");
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, String.Join(System.Environment.NewLine, msg.ToArray()));
}
}
public static List <double> GetUtilizations(Classes_and_structures.Column col, List <int> memberNumbs)
{
//Create new Columns for each of the imported column
foreach (int no in memberNumbs)
{
ProjectPlugIn.Instance.Beams.Add(col.ShallowCopy(no.ToString()));
}
List <double> utilzTot = new List <double>();
OpenConnection();
try
{
Dictionary <int, Tuple <int, double> > utilz = new Dictionary <int, Tuple <int, double> >();
foreach (int numb in memberNumbs)
{
utilz.Add(numb, Tuple.Create(0, 0.0));
}
ICalculation calc = RModel.GetCalculation();
IModelData data = RModel.GetModelData();
ILoads loads = RModel.GetLoads();
LoadCombination[] lc = loads.GetLoadCombinations();
//int[] numbs = lc.Select(o => o.Loading.No).ToArray();
//numbs = Array.FindAll(numbs, o => o > 100 || o < 200);
List <int> numbs = new List <int>()
{
149, 150, 153, 154, 157, 158, 159, 160, 166
};
int k = 0;
foreach (int number in numbs)
{
IResults res = calc.GetResultsInFeNodes(LoadingType.LoadCombinationType, number);
MemberForces[] mfs = res.GetMembersInternalForces(true);
ProjectPlugIn ppi = ProjectPlugIn.Instance;
SimpleLoadCase slc;
for (int i = 0; i < mfs.Length; i++)
{
if (memberNumbs.Contains(mfs[i].MemberNo))
{
slc = new SimpleLoadCase(mfs[i].Forces.X, mfs[i].Moments.Z, mfs[i].Moments.Y,
col, number.ToString(), LimitState.Ultimate);
if (slc.Utilization > utilz[mfs[i].MemberNo].Item2)
{
utilz[mfs[i].MemberNo] = Tuple.Create(i, slc.Utilization);
}
}
}
foreach (int key in utilz.Keys)
{
Classes_and_structures.Column tempCol = (Classes_and_structures.Column)ProjectPlugIn.Instance.Beams
.Find(o => o.Name == key.ToString());
tempCol.LoadCases.Add(new SimpleLoadCase(mfs[utilz[key].Item1].Forces.X, mfs[utilz[key].Item1].Moments.Z, mfs[utilz[key].Item1].Moments.Y,
tempCol, number.ToString(), LimitState.Ultimate));
}
mfs = null;
k++;
}
foreach (int memberNo in memberNumbs)
{
Classes_and_structures.Column tempCol = (Classes_and_structures.Column)ProjectPlugIn.Instance.Beams
.Find(o => o.Name == memberNo.ToString());
SimpleLoadCase[] temp = tempCol.LoadCases.Select(o => o as SimpleLoadCase).ToArray();
utilzTot.Add(temp.MaxBy(o => o.Utilization).Utilization);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, ex.Source, MessageBoxButtons.OK, MessageBoxIcon.Error);
//Cleans Garbage collector for releasing all COM interfaces and objects
System.GC.Collect();
System.GC.WaitForPendingFinalizers();
}
finally
{
CloseConnection();
}
return(utilzTot);
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object can be used to retrieve data from input parameters and
/// to store data in output parameters.</param>
protected override void SolveInstance(IGH_DataAccess DA, EvaluationUnit unit)
{
// Input counter
modelDataCount1 = modelDataCount + modelDataCount2;
// RFEM variables
var modelName = "";
IModel model = null;
IModelData data = null;
ILoads loads = null;
// Assign GH Input
bool getnodes = false;
bool getlines = false;
bool getmembers = false;
bool getsurfaces = false;
bool getopenings = false;
bool getsupportsP = false;
bool getsupportsL = false;
bool getLineHinges = false;
bool getCroSecs = false;
bool getMaterials = false;
bool getNodalLoads = false;
bool run = false;
var ghFilters = new List <GH_RFFilter>();
var inFilters = new List <RFFilter>();
DA.GetData(0, ref getnodes);
DA.GetData(1, ref getlines);
DA.GetData(2, ref getmembers);
DA.GetData(3, ref getsurfaces);
DA.GetData(4, ref getopenings);
DA.GetData(5, ref getsupportsP);
DA.GetData(6, ref getsupportsL);
DA.GetData(7, ref getLineHinges);
DA.GetData(8, ref getCroSecs);
DA.GetData(9, ref getMaterials);
DA.GetData(10, ref run);
DA.GetData(11, ref getNodalLoads);
if (DA.GetDataList(modelDataCount1, ghFilters))
{
inFilters = ghFilters.Select(x => x.Value).ToList();
}
// Do stuff
if (run)
{
if (!DA.GetData(modelDataCount1 + 1, ref modelName))
{
Component_GetData.ConnectRFEM(ref model, ref data);
}
else
{
Component_GetData.ConnectRFEM(modelName, ref model, ref data);
}
Component_GetData.ClearOutput(ref rfNodes, ref rfLines, ref rfMembers, ref rfSurfaces, ref rfOpenings,
ref rfSupportsP, ref rfSupportsL, ref rfLineHinges, ref rfCroSecs, ref rfMaterials, ref rfNodalLoads);
try
{
if (getnodes)
{
var filNodes = Component_GetData.FilterNodes(data, inFilters);
rfNodes = Component_GetData.GetRFNodes(filNodes, data);
}
if (getlines)
{
var filLines = Component_GetData.FilterLines(data, inFilters);
rfLines = Component_GetData.GetRFLines(filLines, data);
}
if (getmembers)
{
var filMembers = Component_GetData.FilterMembers(data, inFilters);
rfMembers = Component_GetData.GetRFMembers(filMembers, data);
}
if (getsurfaces)
{
var filSrfcs = Component_GetData.FilterSurfaces(data, inFilters);
rfSurfaces = Component_GetData.GetRFSurfaces(filSrfcs, data);
}
if (getopenings)
{
var filOpenings = Component_GetData.FilterOpenings(data, inFilters);
rfOpenings = Component_GetData.GetRFOpenings(filOpenings, data);
}
if (getsupportsP)
{
var filSupportsP = Component_GetData.FilterSupsP(data, inFilters);
rfSupportsP = Component_GetData.GetRFSupportsP(filSupportsP, data);
}
if (getsupportsL)
{
var filSupportsL = Component_GetData.FilterSupsL(data, inFilters);
rfSupportsL = Component_GetData.GetRFSupportsL(filSupportsL, data);
}
if (getLineHinges)
{
var filLineHinges = Component_GetData.FilterLH(data, inFilters);
rfLineHinges = Component_GetData.GetRFLineHinges(filLineHinges, data);
}
if (getCroSecs)
{
var filCroSecs = Component_GetData.FilterCroSecs(data, inFilters);
rfCroSecs = Component_GetData.GetRFCroSecs(filCroSecs, data);
}
if (getMaterials)
{
var filMaterials = Component_GetData.FilterMaterials(data, inFilters);
rfMaterials = Component_GetData.GetRFMaterials(filMaterials, data);
}
//Get Loads?
if (getNodalLoads)
{
Component_GetData.GetLoadsFromRFEM(model, ref loads);
}
if (getNodalLoads)
{
var filNodalLoads = Component_GetData.FilterNodalLoads(data, loads, inFilters);
rfNodalLoads = Component_GetData.GetRFNodalLoads(filNodalLoads, data);
}
}
catch (Exception ex)
{
Component_GetData.ClearOutput(ref rfNodes, ref rfLines, ref rfMembers, ref rfSurfaces, ref rfOpenings,
ref rfSupportsP, ref rfSupportsL, ref rfLineHinges, ref rfCroSecs, ref rfMaterials, ref rfNodalLoads);
throw ex;
}
Component_GetData.DisconnectRFEM(ref model, ref data);
}
// Assign GH Output
DA.SetDataList(0, rfNodes);
DA.SetDataList(1, rfLines);
DA.SetDataList(2, rfMembers);
DA.SetDataList(3, rfSurfaces);
DA.SetDataList(4, rfOpenings);
DA.SetDataList(5, rfSupportsP);
DA.SetDataList(6, rfSupportsL);
DA.SetDataList(7, rfLineHinges);
DA.SetDataList(8, rfCroSecs);
DA.SetDataList(9, rfMaterials);
DA.SetDataList(10, rfNodalLoads);
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object can be used to retrieve data from input parameters and
/// to store data in output parameters.</param>
protected override void SolveInstance(IGH_DataAccess DA, EvaluationUnit unit)
{
//OnComponentLoaded();
// Input counter
//modelDataCount1 = 1 + modelDataCount2;
// RFEM variables
var modelName = "";
IModel model = null;
IModelData data = null;
ILoads loads = null;
// Output message
var msg = new List <string>();
// Assign GH Input
bool run = false;
var scale = 0.0;
DA.GetData(0, ref run);
DA.GetData(1, ref scale);
// Do stuff
if (run)
{
if (!DA.GetData(3, ref modelName))
{
Component_GetData.ConnectRFEM(ref model, ref data);
}
else
{
Component_GetData.ConnectRFEM(modelName, ref model, ref data);
}
_saveddata = data;
try
{
// Get deformtions
_resetLC = true;
// Get loads
Component_GetData.GetLoadsFromRFEM(model, ref loads);
// Get calculation results
_results = model.GetCalculation();
var errors = _results.CalculateAll();
if (errors != null)
{
msg.AddRange(errors.Select(x => x.Description));
}
// Update load cases and combos to display in dropdown menu
loads.GetLoadCasesAndCombos(ref _lCasesAndCombos, ref _countCases, ref _countCombos, ref _countRcombos);
updateDropDownMenu(_lCasesAndCombos);
// Get Fe Meshes from RFEM
_rfemMesh = _results.GetFeMesh();
_feMeshes = CreateFEMeshes(ref msg);
// _controlPoints = CreateControlPoints(ref msg); -> Obtained with displacements
}
catch (Exception ex)
{
// Clear output!!!
_saveddata = null;
_rfemMesh = null;
_results = null;
_lcresults = null;
_feMeshes.Clear();
_meshdisplacements.Clear();
_deformedMeshes.Clear();
_controlPoints.Clear();
_memberdisplacements.Clear();
_deformedMembers.Clear();
throw ex;
}
Component_GetData.DisconnectRFEM(ref model, ref data);
}
// Get results to display
if (_loadDrop.Items.Count > 0 && _resetLC && msg.Count == 0)
{
int no = Int16.Parse(_loadDrop.Items[_loadDrop.Value].name.Split(' ')[1]);
if (_loadDrop.Value < _countCases)
{
_lcresults = _results.GetResultsInFeNodes(LoadingType.LoadCaseType, no);
}
else if (_loadDrop.Value < _countCases + _countCombos)
{
_lcresults = _results.GetResultsInFeNodes(LoadingType.LoadCombinationType, no);
}
else if (_loadDrop.Value < _countCases + _countCombos + _countRcombos)
{
_lcresults = _results.GetResultsInFeNodes(LoadingType.ResultCombinationType, no);
}
else
{
msg.Add("Load case or combo not found");
}
// Get deformations
_meshdisplacements = GetMeshDisplacements(ref msg);
_memberdisplacements = GetMemberDisplacements(ref msg);
// Set _resetLC to false again
_resetLC = false;
}
// Get output
_deformedMeshes = GetDeformedMeshes(scale, ref msg);
_deformedMembers = GetDeformedMembers(scale, ref msg);
// Assign GH Output
DA.SetDataTree(0, _deformedMembers);
DA.SetDataTree(1, _deformedMeshes);
if (msg.Count != 0)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, String.Join(System.Environment.NewLine, msg.ToArray()));
}
}
private void button3_Click(object sender, EventArgs e)
{
chart1.Series["deflection"].Points.Clear();
IApplication app = null;
IModel rModel = null;
ILoads rLoads = null;
try
{
//Get active RFEM5 application
app = Marshal.GetActiveObject("RFEM5.Application") as IApplication;
app.LockLicense();
rModel = app.GetActiveModel();
rLoads = rModel.GetLoads();
/*
* ILoadCase lcBase = rLoads.GetLoadCase(1, ItemAt.AtNo);
* AnalysisParameters param = lcBase.GetAnalysisParameters();
* param.ModifyLoadingByFactor = true;
* param.LoadingFactor = param.LoadingFactor + 0.1;
* LoadCase lc = lcBase.GetData();
*/
ICalculation calc = rModel.GetCalculation();
ErrorInfo[] err = { };
int i = 2;
double mult = 1.1;
double addor = 1;
while (Math.Abs(addor) > 0.1)
{
duStuff(rLoads, mult, i, ref err, ref calc);
if (err.Length != 0)
{
addor = (Math.Abs(addor) - 0.1) * -1;
}
else
{
addor = Math.Abs(addor);
}
mult += addor;
i++;
}
mult -= addor + 0.05;
i++;
duStuff(rLoads, mult, i, ref err, ref calc);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, ex.Source, MessageBoxButtons.OK, MessageBoxIcon.Error);
//Release COM object
}
finally
{
rLoads = null;
rModel = null;
app.UnlockLicense();
app = null;
//Cleans Garbage collector for releasing all COM interfaces and objects
System.GC.Collect();
System.GC.WaitForPendingFinalizers();
}
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object can be used to retrieve data from input parameters and
/// to store data in output parameters.</param>
protected override void SolveInstance(IGH_DataAccess DA, EvaluationUnit unit)
{
// RFEM variables
var modelName = "";
IModel model = null;
IModelData data = null;
ILoads loads = null;
ICalculation results = null;
// Output message
var msg = new List <string>();
// Assign GH Input
bool run = false;
var iLcases = new List <string>();
DA.GetData(0, ref run);
// Do stuff
if (run)
{
if (!DA.GetData(3, ref modelName))
{
Component_GetData.ConnectRFEM(ref model, ref data);
}
else
{
Component_GetData.ConnectRFEM(modelName, ref model, ref data);
}
try
{
// Get loads
Component_GetData.GetLoadsFromRFEM(model, ref loads);
// Get calculation
results = model.GetCalculation();
// Update results
_maxDisplacements = new List <Vector3d>();
_loadCasesAndCombos = new List <string>();
// Get load cases and combos
if (!DA.GetDataList(1, iLcases))
{
var errors = results.CalculateApp();
if (errors != null)
{
msg.AddRange(errors.Select(x => x.Description));
}
_loadCasesAndCombos = loads.GetLoadCasesAndCombos(0, 0, 0);
}
else
{
_loadCasesAndCombos = iLcases;
}
// Get results
foreach (var lc in _loadCasesAndCombos)
{
Vector3d displacement = new Vector3d(0, 0, 0);
Component_GetResults.GetResults(ref results, lc, ref displacement, ref msg);
_maxDisplacements.Add(displacement);
}
}
catch (Exception ex)
{
// Clear output!!!
results = null;
_maxDisplacements = null;
_loadCasesAndCombos = null;
Component_GetData.DisconnectRFEM(ref model, ref data);
throw ex;
}
Component_GetData.DisconnectRFEM(ref model, ref data);
}
if (msg.Count > 0)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, String.Join(System.Environment.NewLine, msg.ToArray()));
}
{
DA.SetDataList(0, _loadCasesAndCombos);
DA.SetDataList(1, _maxDisplacements);
}
}
