/***************************************************/
private List <MeshStress> SmoothenStresses(List <MeshStress> forces)
{
List <MeshStress> smoothenedForces = new List <MeshStress>();
foreach (IEnumerable <MeshStress> group in forces.GroupBy(x => new { x.ResultCase, x.TimeStep, x.NodeId }))
{
MeshStress first = group.First();
double sxx = group.Average(x => x.SXX);
double syy = group.Average(x => x.SYY);
double sxy = group.Average(x => x.SXY);
double txx = group.Average(x => x.TXX);
double tyy = group.Average(x => x.TYY);
double pr1 = group.Average(x => x.Principal_1);
double pr2 = group.Average(x => x.Principal_2);
double pr1_2 = group.Average(x => x.Principal_1_2);
smoothenedForces.Add(new MeshStress(first.ObjectId, first.NodeId, "", first.ResultCase, first.ModeNumber, first.TimeStep, first.MeshResultLayer, first.LayerPosition, MeshResultSmoothingType.ByPanel, first.Orientation, sxx, syy, sxy, txx, tyy, pr1, pr2, pr1_2));
}
return(smoothenedForces);
}
/***************************************************/
private IEnumerable <IResult> ExtractMeshStress(List <int> ids, List <int> loadcaseIds, MeshResultLayer meshResultLayer)
{
List <MeshStress> meshStresses = new List <MeshStress>();
IFView view = m_LusasApplication.getCurrentView();
IFResultsContext resultsContext = m_LusasApplication.newResultsContext(view);
string entity;
switch (meshResultLayer)
{
case MeshResultLayer.Lower:
entity = "Stress (bottom) - Thick Shell";
break;
case MeshResultLayer.Middle:
entity = "Stress (middle) - Thick Shell";
break;
case MeshResultLayer.Upper:
entity = "Stress (top) - Thick Shell";
break;
default:
entity = "Stress (middle) - Thick Shell";
Engine.Base.Compute.RecordWarning("No valid MeshLayerPosition provided, therefore it has defaulted to middle (i.e. 0.5).");
break;
}
string location = "Feature extreme";
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>()
{
"SX", "SY", "SZ", "SYZ", "SZX", "S1", "S3", "S2"
};
d_LusasData.startUsingScriptedResults();
Dictionary <string, IFResultsComponentSet> resultsSets = GetResultsSets(entity, components, location, resultsContext);
foreach (int meshId in ids)
{
Dictionary <string, double> featureResults = GetFeatureResults(components, resultsSets, unitSet, meshId, "S", 6);
double sX = 0; double sY = 0; double sZ = 0; double sYZ = 0; double sXZ = 0; double s1 = 0; double s3 = 0; double s2 = 0;
featureResults.TryGetValue("SX", out sX); featureResults.TryGetValue("SY", out sY); featureResults.TryGetValue("SZ", out sZ);
featureResults.TryGetValue("SYZ", out sYZ); featureResults.TryGetValue("SZX", out sXZ);
featureResults.TryGetValue("S1", out s1); featureResults.TryGetValue("S3", out s3); featureResults.TryGetValue("S2", out s2);
int mode = -1;
MeshStress meshStress = new MeshStress(
meshId, 0, 0, loadcaseId, mode, 0, MeshResultLayer.Middle, 0.5, MeshResultSmoothingType.ByPanel, null,
sX * forceSIConversion / (lengthSIConversion * lengthSIConversion),
sY * forceSIConversion / (lengthSIConversion * lengthSIConversion),
sZ * forceSIConversion / (lengthSIConversion * lengthSIConversion),
sYZ * forceSIConversion / (lengthSIConversion * lengthSIConversion),
sXZ * forceSIConversion / (lengthSIConversion * lengthSIConversion),
s1 * forceSIConversion / (lengthSIConversion * lengthSIConversion),
s3 * forceSIConversion / (lengthSIConversion * lengthSIConversion),
s2 * forceSIConversion / (lengthSIConversion * lengthSIConversion)
);
meshStresses.Add(meshStress);
}
d_LusasData.stopUsingScriptedResults();
d_LusasData.flushScriptedResults();
}
return(meshStresses);
}
/***************************************************/
//Method atempting to extract results using AreaStressLayered method. API call is currently never returning any results for this.
//Keeping for further reference. Method is not called from anywhere
private List <MeshResult> ReadMeshStressLayered(List <string> panelIds, MeshResultSmoothingType smoothing, List <string> cases)
{
switch (smoothing)
{
case MeshResultSmoothingType.BySelection:
case MeshResultSmoothingType.Global:
case MeshResultSmoothingType.ByFiniteElementCentres:
Engine.Base.Compute.RecordWarning("Smoothing type not supported for MeshStress. No results extracted");
return(new List <MeshResult>());
}
eItemTypeElm itemTypeElm = eItemTypeElm.ObjectElm;
int resultCount = 0;
string[] obj = null;
string[] elm = null;
string[] layer = null;
int[] intPtNb = null;
double[] layerPos = null;
string[] pointElm = null;
string[] loadCase = null;
string[] stepType = null;
double[] stepNum = null;
double[] s11 = null;
double[] s22 = null;
double[] s12 = null;
double[] sMax = null;
double[] sMin = null;
double[] sAng = null;
double[] svm = null;
double[] s13 = null;
double[] s23 = null;
double[] sMaxAvg = null;
double[] sAngAvg = null;
List <MeshResult> results = new List <MeshResult>();
if (smoothing == MeshResultSmoothingType.ByPanel)
{
Engine.Base.Compute.RecordWarning("Stress values have been smoothened outside the API by averaging all force values in each node");
}
foreach (string caseName in cases)
{
m_model.Results.Setup.DeselectAllCasesAndCombosForOutput();
if (!SetUpCaseOrCombo(caseName))
{
continue;
}
for (int i = 0; i < panelIds.Count; i++)
{
List <MeshStress> stresses = new List <MeshStress>();
int ret = m_model.Results.AreaStressShellLayered(panelIds[i], itemTypeElm, ref resultCount, ref obj, ref elm, ref layer, ref intPtNb, ref layerPos, ref pointElm, ref loadCase, ref stepType, ref stepNum, ref s11, ref s22, ref s12, ref sMax, ref sMin, ref sAng, ref svm, ref s13, ref s23, ref sMaxAvg, ref sAngAvg);
if (ret == 0)
{
for (int j = 0; j < resultCount - 1; j++)
{
int mode;
double timeStep;
GetStepAndMode(stepType[j], stepNum[j], out timeStep, out mode);
MeshStress mStress = new MeshStress(panelIds[i], pointElm[j], elm[j], loadCase[j], mode, timeStep, MeshResultLayer.Arbitrary, layerPos[j], MeshResultSmoothingType.None, oM.Geometry.Basis.XY, s11[j], s22[j], s12[j], s13[j], s23[j], sMax[j], sMin[j], sMaxAvg[j]);
stresses.Add(mStress);
}
if (smoothing == MeshResultSmoothingType.ByPanel)
{
stresses = SmoothenStresses(stresses);
}
results.AddRange(GroupMeshResults(stresses));
}
else
{
Engine.Base.Compute.RecordWarning("Failed to extract results for element " + panelIds[i] + " for case " + caseName);
}
}
}
return(results);
}
/***************************************************/
private List <MeshResult> ReadMeshStress(List <string> panelIds, List <string> cases, MeshResultSmoothingType smoothing, MeshResultLayer layer)
{
switch (smoothing)
{
case MeshResultSmoothingType.BySelection:
case MeshResultSmoothingType.Global:
case MeshResultSmoothingType.ByFiniteElementCentres:
Engine.Base.Compute.RecordWarning("Smoothing type not supported for MeshStress. No results extracted");
return(new List <MeshResult>());
}
if (layer == MeshResultLayer.Upper || layer == MeshResultLayer.Lower)
{
Engine.Base.Compute.RecordWarning("Results for both bot and top layers will be extracted at the same time");
}
else
{
Engine.Base.Compute.RecordWarning("Stress extraction is currently only possible at bot and top layers. Please update the MeshResultLayer parameter");
return(new List <MeshResult>());
}
eItemTypeElm itemTypeElm = eItemTypeElm.ObjectElm;
int resultCount = 0;
string[] obj = null;
string[] elm = null;
string[] pointElm = null;
string[] loadCase = null;
string[] stepType = null;
double[] stepNum = null;
double[] s11Top = null;
double[] s22Top = null;
double[] s12Top = null;
double[] sMaxTop = null;
double[] sMinTop = null;
double[] sAngTop = null;
double[] svmTop = null;
double[] s11Bot = null;
double[] s22Bot = null;
double[] s12Bot = null;
double[] sMaxBot = null;
double[] sMinBot = null;
double[] sAngBot = null;
double[] svmBot = null;
double[] s13Avg = null;
double[] s23Avg = null;
double[] sMaxAvg = null;
double[] sAngAvg = null;
List <MeshResult> results = new List <MeshResult>();
if (smoothing == MeshResultSmoothingType.ByPanel)
{
Engine.Base.Compute.RecordWarning("Stress values have been smoothed outside the API by averaging all force values in each node");
}
foreach (string caseName in cases)
{
m_model.Results.Setup.DeselectAllCasesAndCombosForOutput();
if (!SetUpCaseOrCombo(caseName))
{
continue;
}
for (int i = 0; i < panelIds.Count; i++)
{
List <MeshStress> stressTop = new List <MeshStress>();
List <MeshStress> stressBot = new List <MeshStress>();
int ret = m_model.Results.AreaStressShell(panelIds[i], itemTypeElm, ref resultCount, ref obj, ref elm, ref pointElm, ref loadCase, ref stepType, ref stepNum, ref s11Top, ref s22Top, ref s12Top, ref sMaxTop, ref sMinTop, ref sAngTop, ref svmTop, ref s11Bot, ref s22Bot, ref s12Bot, ref sMaxBot, ref sMinBot, ref sAngBot, ref svmBot, ref s13Avg, ref s23Avg, ref sMaxAvg, ref sAngAvg);
if (ret == 0)
{
for (int j = 0; j < resultCount; j++)
{
int mode;
double timeStep;
GetStepAndMode(stepType[j], stepNum[j], out timeStep, out mode);
MeshStress mStressTop = new MeshStress(panelIds[i], pointElm[j], elm[j], loadCase[j], mode, timeStep, MeshResultLayer.Upper, 1, MeshResultSmoothingType.None, oM.Geometry.Basis.XY, s11Top[j], s22Top[j], s12Top[j], s13Avg[j], s23Avg[j], sMaxTop[j], sMinTop[j], double.NaN);
MeshStress mStressBot = new MeshStress(panelIds[i], pointElm[j], elm[j], loadCase[j], mode, timeStep, MeshResultLayer.Lower, 0, MeshResultSmoothingType.None, oM.Geometry.Basis.XY, s11Bot[j], s22Bot[j], s12Bot[j], s13Avg[j], s23Avg[j], sMaxBot[j], sMinBot[j], double.NaN);
stressBot.Add(mStressBot);
stressTop.Add(mStressTop);
}
if (smoothing == MeshResultSmoothingType.ByPanel)
{
stressTop = SmoothenStresses(stressTop);
stressBot = SmoothenStresses(stressBot);
}
results.AddRange(GroupMeshResults(stressBot));
results.AddRange(GroupMeshResults(stressTop));
}
else
{
Engine.Base.Compute.RecordWarning("Failed to extract results for element " + panelIds[i] + " for case " + caseName);
}
}
}
return(results);
}
