/***************************************************/
/**** Private methods ****/
/***************************************************/
private List <NodeReaction> ReadNodeReaction(List <string> ids = null)
{
//Implement code for reading Node Reactions
List <NodeReaction> bhomNodeReactions = new List <NodeReaction>();
IModel ramModel = m_Application.GetDispInterfacePointerByEnum(EINTERFACES.IModel_INT);
ILoadCases ramLoadCases = ramModel.GetLoadCases(EAnalysisResultType.RAMFrameResultType);
//Get IWalls
List <IWall> allRamWalls = ReadRamWalls(ramModel);
// Adding node reactions per wall per loadcase, this is node reactions at btm of wall
foreach (IWall wall in allRamWalls)
{
for (int i = 0; i < ramLoadCases.GetCount(); i++)
{
//Get Loadcases
ILoadCase ramLoadCase = ramLoadCases.GetAt(i);
IPointLoads wallNodeForces = wall.GetNodeForcesAtEdge(EAnalysisResultType.RAMGravityResultType, ramLoadCase.lUID, EEdge.eBottomEdge);
for (int j = 0; j < wallNodeForces.GetCount(); j++)
{
//Get Node Forces
IPointLoad wallNodeForce = wallNodeForces.GetAt(j);
NodeReaction bhomNodeReaction = wallNodeForce.ToBHoMObject(ramLoadCase);
bhomNodeReactions.Add(bhomNodeReaction);
}
}
}
return(bhomNodeReactions);
}
/***************************************************/
public static NodeReaction ToBHoMObject(this IPointLoad ramPointLoad, ILoadCase ramLoadCase)
{
SCoordinate ramPoint;
ramPointLoad.GetCoordinate(out ramPoint);
Point bhomPoint = ramPoint.PointFromRAM();
string ramPointID = bhomPoint.X.ToString() + ", " + bhomPoint.Y.ToString() + ", " + bhomPoint.Z.ToString() + ", "; // no object id option for RAM nodes, id by coordinates instead
//TODO: resolve below identifiers extractable through the API
int mode = -1;
double timeStep = 0;
NodeReaction bhomNodeReaction = new NodeReaction(
ramPointID,
ramLoadCase.strLoadCaseGroupLabel + ramLoadCase.strTypeLabel,
mode,
timeStep,
Basis.XY,
ramPointLoad.dFx,
ramPointLoad.dFy,
ramPointLoad.dFz,
ramPointLoad.dMxx,
ramPointLoad.dMyy,
ramPointLoad.dMzz
);
return(bhomNodeReaction);
}
/***************************************************/
private List <NodeReaction> ReadNodeReaction(List <string> nodeIds)
{
List <NodeReaction> nodeReactions = new List <NodeReaction>();
int resultCount = 0;
string[] loadcaseNames = null;
string[] objects = null;
string[] elm = null;
string[] stepType = null;
double[] stepNum = null;
double[] fx = null;
double[] fy = null;
double[] fz = null;
double[] mx = null;
double[] my = null;
double[] mz = null;
for (int i = 0; i < nodeIds.Count; i++)
{
int ret = m_model.Results.JointReact(nodeIds[i],
eItemTypeElm.ObjectElm,
ref resultCount,
ref objects,
ref elm,
ref loadcaseNames,
ref stepType,
ref stepNum,
ref fx,
ref fy,
ref fz,
ref mx,
ref my,
ref mz);
if (ret == 0)
{
for (int j = 0; j < resultCount; j++)
{
NodeReaction nr = new NodeReaction(nodeIds[i], loadcaseNames[j], -1, stepNum[j], oM.Geometry.Basis.XY, fx[j], fy[j], fz[j], mx[j], my[j], mz[j]);
nodeReactions.Add(nr);
}
}
}
return(nodeReactions);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private IEnumerable <IResult> ExtractNodeReaction(List <int> ids, List <int> loadcaseIds)
{
List <NodeReaction> nodeReactions = new List <NodeReaction>();
IFView view = m_LusasApplication.getCurrentView();
IFResultsContext resultsContext = m_LusasApplication.newResultsContext(view);
string entity = "Reaction";
string location = "Nodal";
foreach (int loadcaseId in loadcaseIds)
{
IFLoadset loadset = d_LusasData.getLoadset(loadcaseId);
if (!loadset.needsAssociatedValues())
{
resultsContext.setActiveLoadset(loadset);
}
IFUnitSet unitSet = d_LusasData.getModelUnits();
double forceSIConversion = 1 / unitSet.getForceFactor();
double lengthSIConversion = 1 / unitSet.getLengthFactor();
List <string> components = new List <string>()
{
"Fx", "Fy", "Fz", "Mx", "My", "Mz"
};
d_LusasData.startUsingScriptedResults();
Dictionary <string, IFResultsComponentSet> resultsSets = GetResultsSets(entity, components, location, resultsContext);
foreach (int nodeId in ids)
{
Dictionary <string, double> featureResults = GetFeatureResults(components, resultsSets, unitSet, nodeId, "P", 6);
double fX = 0; double fY = 0; double fZ = 0; double mX = 0; double mY = 0; double mZ = 0;
featureResults.TryGetValue("Fx", out fX); featureResults.TryGetValue("Fy", out fY); featureResults.TryGetValue("Fz", out fZ);
featureResults.TryGetValue("Mx", out mX); featureResults.TryGetValue("My", out mY); featureResults.TryGetValue("Mz", out mZ);
List <double> results = new List <double>();
//TODO: resolve below identifiers extractable through the API
int mode = -1;
double timeStep = 0;
NodeReaction nodeReaction = new NodeReaction(
nodeId,
Adapters.Lusas.Convert.GetName(loadset.getName()),
mode,
timeStep,
oM.Geometry.Basis.XY,
fX * forceSIConversion,
fY * forceSIConversion,
fZ * forceSIConversion,
mX * forceSIConversion * lengthSIConversion,
mY * forceSIConversion * lengthSIConversion,
mZ * forceSIConversion * lengthSIConversion
);
nodeReactions.Add(nodeReaction);
}
d_LusasData.stopUsingScriptedResults();
d_LusasData.flushScriptedResults();
}
return(nodeReactions);
}
private IEnumerable <IResult> GetNodeResults(Type type, IList ids = null, IList cases = null)
{
List <NodeResult> results = new List <NodeResult>();
int resultType = -1;
if (type == typeof(NodeAcceleration))
{
resultType = St7.rtNodeAcc;
}
else if (type == typeof(NodeDisplacement))
{
resultType = St7.rtNodeDisp;
}
else if (type == typeof(NodeReaction))
{
resultType = St7.rtNodeReact;
}
else if (type == typeof(NodeVelocity))
{
resultType = St7.rtNodeVel;
}
List <int> loadcaseIds = new List <int>();
List <int> nodeIds = new List <int>();
int err;
// checking node ids
if (ids == null || ids.Count == 0)
{
int nodeCount = 0;
err = St7.St7GetTotal(1, St7.tyNODE, ref nodeCount);
if (!St7Error(err))
{
return(null);
}
nodeIds = Enumerable.Range(1, nodeCount).ToList();
}
else
{
nodeIds = ids.Cast <int>().ToList();
}
// checking load ids
if (cases == null)
{
BHError("No load cases are provided");
}
else
{
foreach (object one_case in cases)
{
if (one_case is ICase)
{
loadcaseIds.Add(GetAdapterId <int>(one_case as ICase));
}
else if (one_case is int)
{
loadcaseIds.Add((int)one_case);
}
}
}
double[] nodeResArray = new double[6];
NodeResult nd;
foreach (int loadcaseId in loadcaseIds)
{
double caseTime = 0;
err = St7.St7GetResultCaseTime(1, loadcaseId, ref caseTime);
foreach (int nodeId in nodeIds)
{
err = St7.St7GetNodeResult(1, resultType, nodeId, loadcaseId, nodeResArray);
switch (resultType)
{
case St7.rtNodeAcc:
nd = new NodeAcceleration(nodeId, loadcaseId, 1, caseTime, oM.Geometry.Basis.XY, nodeResArray[0], nodeResArray[1], nodeResArray[2], nodeResArray[3], nodeResArray[4], nodeResArray[5]);
break;
case St7.rtNodeDisp:
nd = new NodeDisplacement(nodeId, loadcaseId, 1, caseTime, oM.Geometry.Basis.XY, nodeResArray[0], nodeResArray[1], nodeResArray[2], nodeResArray[3], nodeResArray[4], nodeResArray[5]);
break;
case St7.rtNodeVel:
nd = new NodeVelocity(nodeId, loadcaseId, 1, caseTime, oM.Geometry.Basis.XY, nodeResArray[0], nodeResArray[1], nodeResArray[2], nodeResArray[3], nodeResArray[4], nodeResArray[5]);
break;
case St7.rtNodeReact:
nd = new NodeReaction(nodeId, loadcaseId, 1, caseTime, oM.Geometry.Basis.XY, nodeResArray[0], nodeResArray[1], nodeResArray[2], nodeResArray[3], nodeResArray[4], nodeResArray[5]);
break;
default:
nd = null;
BHError("Unknown Result type");
break;
}
results.Add(nd);
}
}
return(results);
}
/***************************************************/
public static NodeReaction ToBHoMObject(this IMemberForce ramForce)
{
NodeReaction bhomNodeReaction = new NodeReaction("", "", -1, 0, Basis.XY, ramForce.dAxial, ramForce.dShearMinor, ramForce.dShearMajor, ramForce.dTorsion, ramForce.dMomentMajor, ramForce.dMomentMinor);
return(bhomNodeReaction);
}
public static List<NodeReaction> GetNodeReaction(cSapModel model, IList ids = null, IList cases = null)
{
List<string> loadcaseIds = new List<string>();
List<string> nodeIds = new List<string>();
List<NodeReaction> nodeReactions = new List<NodeReaction>();
if (ids == null)
{
int nodes = 0;
string[] names = null;
model.PointObj.GetNameList(ref nodes, ref names);
nodeIds = names.ToList();
}
else
{
for (int i = 0; i < ids.Count; i++)
{
nodeIds.Add(ids[i].ToString());
}
}
//Get out loadcases, get all for null list
loadcaseIds = CheckAndGetCases(model, cases);
int resultCount = 0;
string[] loadcaseNames = null;
string[] objects = null;
string[] elm = null;
string[] stepType = null;
double[] stepNum = null;
double[] fx = null;
double[] fy = null;
double[] fz = null;
double[] mx = null;
double[] my = null;
double[] mz = null;
model.Results.Setup.DeselectAllCasesAndCombosForOutput();
for (int loadcase = 0; loadcase < loadcaseIds.Count; loadcase++)
{
if (model.Results.Setup.SetCaseSelectedForOutput(loadcaseIds[loadcase]) != 0)
{
model.Results.Setup.SetComboSelectedForOutput(loadcaseIds[loadcase]);
}
}
//List<NodeReaction<string, string, string>> nodeForces = new List<NodeReaction<string, string, string>>();
for (int i = 0; i < nodeIds.Count; i++)
{
int ret = model.Results.JointReact(nodeIds[i], eItemTypeElm.ObjectElm, ref resultCount, ref objects, ref elm,
ref loadcaseNames, ref stepType, ref stepNum, ref fx, ref fy, ref fz, ref mx, ref my, ref mz);
if (ret == 0)
{
for (int j = 0; j < resultCount; j++)
{
//string step = stepType[j] != null ? stepType[j] == "Max" ? " Max" : stepType[j] == "Min" ? " Min" : "1" : "0";
//nodeForces.Add(new NodeReaction<string, string, string>(objects[j], loadcaseNames[j], step, fx[j], fy[j], fz[j], mx[j], my[j], mz[j]));
NodeReaction nr = new NodeReaction()
{
ResultCase = loadcaseNames[j],
ObjectId = nodeIds[i],
MX = mx[j],
MY = my[j],
MZ = mz[j],
FX = fx[j],
FY = fy[j],
FZ = fz[j],
TimeStep = stepNum[j]
};
nodeReactions.Add(nr);
}
}
}
return nodeReactions;
}
