/***************************************************/
/***************************************************/
/**** Constructors ****/
/***************************************************/
public MeshStress(IComparable objectId,
IComparable nodeId,
IComparable meshFaceId,
IComparable resultCase,
double timeStep,
MeshResultLayer meshResultLayer,
double layerPosition,
MeshResultSmoothingType smoothing,
Geometry.CoordinateSystem.Cartesian coordinateSystem,
double sXX,
double sYY,
double sXY,
double tXX,
double tYY,
double principal_1,
double principal_2,
double principal_1_2) : base(objectId, nodeId, meshFaceId, resultCase, timeStep, meshResultLayer, layerPosition, smoothing, coordinateSystem)
{
SXX = sXX;
SYY = sYY;
SXY = sXY;
TXX = tXX;
TYY = tYY;
Principal_1 = principal_1;
Principal_2 = principal_2;
Principal_1_2 = principal_1_2;
}
/***************************************************/
/**** Constructors ****/
/***************************************************/
public MeshForce(IComparable objectId,
IComparable nodeId,
IComparable meshFaceId,
IComparable resultCase,
double timeStep,
MeshResultLayer meshResultLayer,
double layerPosition,
MeshResultSmoothingType smoothing,
Basis orientation,
double nXX,
double nYY,
double nXY,
double mXX,
double mYY,
double mXY,
double vX,
double vY) : base(objectId, nodeId, meshFaceId, resultCase, timeStep, meshResultLayer, layerPosition, smoothing, orientation)
{
NXX = nXX;
NYY = nYY;
NXY = nXY;
MXX = mXX;
MYY = mYY;
MXY = mXY;
VX = vX;
VY = vY;
}
/***************************************************/
/***************************************************/
/**** Constructors ****/
/***************************************************/
public MeshForce(IComparable objectId,
IComparable nodeId,
IComparable meshFaceId,
IComparable resultCase,
double timeStep,
MeshResultLayer meshResultLayer,
double layerPosition,
MeshResultSmoothingType smoothing,
Geometry.CoordinateSystem.Cartesian coordinateSystem,
double nXX,
double nYY,
double nXY,
double mXX,
double mYY,
double mXY,
double vX,
double vY) : base(objectId, nodeId, meshFaceId, resultCase, timeStep, meshResultLayer, layerPosition, smoothing, coordinateSystem)
{
NXX = nXX;
NYY = nYY;
NXY = nXY;
MXX = mXX;
MYY = mYY;
MXY = mXY;
VX = vX;
VY = vY;
}
public static FilterRequest MeshResult(MeshResultSmoothingType smoothing,
MeshResultLayer layer,
double layerPosition,
MeshResultType resultType,
Cartesian coordinateSystem = null,
IEnumerable <object> cases = null,
IEnumerable <object> objectIds = null)
{
FilterRequest request = new FilterRequest();
request.Type = typeof(MeshResult);
request.Equalities["Smoothing"] = smoothing;
request.Equalities["Layer"] = layer;
request.Equalities["LayerPosition"] = layerPosition;
request.Equalities["ResultType"] = resultType;
request.Equalities["CoordinateSystem"] = coordinateSystem;
if (cases != null)
{
request.Equalities["Cases"] = cases.ToList();
}
if (objectIds != null)
{
request.Equalities["ObjectIds"] = objectIds.ToList();
}
return(request);
}
/***************************************************/
private List <MeshResult> ReadMeshDisplacement(List <string> panelIds, MeshResultSmoothingType smoothing)
{
int resultCount = 0;
string[] obj = null;
string[] elm = null;
string[] loadCase = null;
string[] stepType = null;
double[] stepNum = null;
double[] ux = null;
double[] uy = null;
double[] uz = null;
double[] rx = null;
double[] ry = null;
double[] rz = null;
List <MeshResult> results = new List <MeshResult>();
for (int i = 0; i < panelIds.Count; i++)
{
List <MeshDisplacement> displacements = new List <MeshDisplacement>();
HashSet <string> ptNbs = new HashSet <string>();
int nbELem = 0;
string[] elemNames = new string[0];
m_model.AreaObj.GetElm(panelIds[i], ref nbELem, ref elemNames);
for (int j = 0; j < nbELem; j++)
{
//Get out the name of the points for each face
int nbPts = 0;
string[] ptsNames = new string[0];
m_model.AreaElm.GetPoints(elemNames[j], ref nbPts, ref ptsNames);
foreach (string ptId in ptsNames)
{
ptNbs.Add(ptId);
}
}
foreach (string ptId in ptNbs)
{
int ret = m_model.Results.JointDispl(ptId, eItemTypeElm.Element, ref resultCount, ref obj, ref elm, ref loadCase, ref stepType, ref stepNum, ref ux, ref uy, ref uz, ref rx, ref ry, ref rz);
for (int j = 0; j < resultCount; j++)
{
int mode;
double timeStep;
GetStepAndMode(stepType[j], stepNum[j], out timeStep, out mode);
MeshDisplacement disp = new MeshDisplacement(panelIds[i], ptId, "", loadCase[j], mode, timeStep, MeshResultLayer.Middle, 0, MeshResultSmoothingType.Global, Basis.XY, ux[j], uy[j], uz[j], rx[j], ry[j], rz[j]);
displacements.Add(disp);
}
}
results.AddRange(GroupMeshResults(displacements));
}
return(results);
}
/***************************************************/
/***************************************************/
/**** Constructors ****/
/***************************************************/
public MeshStress(IComparable objectId,
IComparable nodeId,
IComparable meshFaceId,
IComparable resultCase,
double timeStep,
MeshResultLayer meshResultLayer,
double layerPosition,
MeshResultSmoothingType smoothing,
Basis orientation,
double sXX,
double sYY,
double sXY,
double tXX,
double tYY,
double principal_1,
double principal_2,
double principal_1_2) : base(objectId, nodeId, meshFaceId, resultCase, timeStep, meshResultLayer, layerPosition, smoothing, orientation)
{
SXX = sXX;
SYY = sYY;
SXY = sXY;
TXX = tXX;
TYY = tYY;
Principal_1 = principal_1;
Principal_2 = principal_2;
Principal_1_2 = principal_1_2;
}
/***************************************************/
/**** Constructors ****/
/***************************************************/
public MeshResults(IComparable objectId, MeshResultLayer resultLayer, MeshResultSmoothingType smoothing, ReadOnlyCollection <MeshResult> meshResultCollection)
{
ObjectId = objectId;
Layer = resultLayer;
LayerPosition = LayerPosition;
Smoothing = smoothing;
MeshResultCollection = meshResultCollection;
}
/***************************************************/
/**** Constructors ****/
/***************************************************/
public MeshResult(IComparable objectId, IComparable resultCase, double timeStep, MeshResultLayer resultLayer, double layerPosition, MeshResultSmoothingType smoothing, ReadOnlyCollection <MeshElementResult> results)
{
ObjectId = objectId;
ResultCase = resultCase;
TimeStep = timeStep;
Layer = resultLayer;
LayerPosition = layerPosition;
Smoothing = smoothing;
Results = results;
}
/***************************************************/
/**** Constructors ****/
/***************************************************/
public MeshResult(IComparable objectId, IComparable resultCase, int modeNumber, double timeStep, MeshResultLayer layer, double layerPosition, MeshResultSmoothingType smoothing, IEnumerable <MeshElementResult> results)
{
ObjectId = objectId;
ResultCase = resultCase;
ModeNumber = modeNumber;
TimeStep = timeStep;
Layer = layer;
LayerPosition = layerPosition;
Smoothing = smoothing;
Results = new ReadOnlyCollection <MeshElementResult>(results.ToList());
}
/***************************************************/
/***************************************************/
/**** Constructors ****/
/***************************************************/
public MeshVonMises(IComparable objectId,
IComparable nodeId,
IComparable meshFaceId,
IComparable resultCase,
double timeStep,
MeshResultLayer meshResultLayer,
double layerPosition,
MeshResultSmoothingType smoothing,
Geometry.CoordinateSystem.Cartesian coordinateSystem,
double s,
double n,
double m) : base(objectId, nodeId, meshFaceId, resultCase, timeStep, meshResultLayer, layerPosition, smoothing, coordinateSystem)
{
S = s;
N = n;
M = m;
}
/***************************************************/
/**** Constructors ****/
/***************************************************/
public MeshVonMises(IComparable objectId,
IComparable nodeId,
IComparable meshFaceId,
IComparable resultCase,
double timeStep,
MeshResultLayer meshResultLayer,
double layerPosition,
MeshResultSmoothingType smoothing,
Basis orientation,
double s,
double n,
double m) : base(objectId, nodeId, meshFaceId, resultCase, timeStep, meshResultLayer, layerPosition, smoothing, orientation)
{
S = s;
N = n;
M = m;
}
/***************************************************/
/**** Constructors ****/
/***************************************************/
protected MeshElementResult(IComparable objectId,
IComparable nodeId,
IComparable meshFaceId,
IComparable resultCase,
double timeStep,
MeshResultLayer meshResultLayer,
double layerPosition,
MeshResultSmoothingType smoothing,
Basis orientation)
{
ObjectId = objectId;
NodeId = nodeId;
MeshFaceId = meshFaceId;
ResultCase = resultCase;
TimeStep = timeStep;
MeshResultLayer = meshResultLayer;
LayerPosition = layerPosition;
Smoothing = smoothing;
Orientation = orientation;
}
/***************************************************/
/**** Constructors ****/
/***************************************************/
protected MeshResult(IComparable objectId,
IComparable nodeId,
IComparable meshFaceId,
IComparable resultCase,
double timeStep,
MeshResultLayer meshResultLayer,
double layerPosition,
MeshResultSmoothingType smoothing,
Geometry.CoordinateSystem.Cartesian coordinateSystem)
{
ObjectId = objectId;
NodeId = nodeId;
MeshFaceId = MeshFaceId;
ResultCase = resultCase;
TimeStep = timeStep;
MeshResultLayer = meshResultLayer;
LayerPosition = layerPosition;
Smoothing = smoothing;
CoordinateSystem = coordinateSystem;
}
/***************************************************/
/***************************************************/
/**** Constructors ****/
/***************************************************/
public MeshDisplacement(IComparable objectId,
IComparable nodeId,
IComparable meshFaceId,
IComparable resultCase,
double timeStep,
MeshResultLayer meshResultLayer,
double layerPosition,
MeshResultSmoothingType smoothing,
Geometry.CoordinateSystem.Cartesian coordinateSystem,
double uXX,
double uYY,
double uZZ,
double rXX,
double rYY,
double rZZ) : base(objectId, nodeId, meshFaceId, resultCase, timeStep, meshResultLayer, layerPosition, smoothing, coordinateSystem)
{
UXX = uXX;
UYY = uYY;
UZZ = uZZ;
RXX = rXX;
RYY = rYY;
RZZ = rZZ;
}
/***************************************************/
/***************************************************/
/**** Constructors ****/
/***************************************************/
public MeshDisplacement(IComparable objectId,
IComparable nodeId,
IComparable meshFaceId,
IComparable resultCase,
double timeStep,
MeshResultLayer meshResultLayer,
double layerPosition,
MeshResultSmoothingType smoothing,
Basis orientation,
double uXX,
double uYY,
double uZZ,
double rXX,
double rYY,
double rZZ) : base(objectId, nodeId, meshFaceId, resultCase, timeStep, meshResultLayer, layerPosition, smoothing, orientation)
{
UXX = uXX;
UYY = uYY;
UZZ = uZZ;
RXX = rXX;
RYY = rYY;
RZZ = rZZ;
}
/***************************************************/
/**** Private methods - Extraction methods ****/
/***************************************************/
private List <MeshResult> ReadMeshForce(List <string> panelIds,
MeshResultSmoothingType smoothing)
{
switch (smoothing)
{
case MeshResultSmoothingType.BySelection:
case MeshResultSmoothingType.Global:
case MeshResultSmoothingType.ByFiniteElementCentres:
Engine.Reflection.Compute.RecordWarning("Smoothing type not supported for MeshForce. No results extracted");
default:
return(new List <MeshResult>());
}
List <MeshResult> results = new List <MeshResult>();
int resultCount = 0;
string[] obj = null;
string[] elm = null;
string[] pointElm = null;
string[] loadCase = null;
string[] stepType = null;
double[] stepNum = null;
double[] f11 = null;
double[] f22 = null;
double[] f12 = null;
double[] fMax = null;
double[] fMin = null;
double[] fAngle = null;
double[] fvm = null;
double[] m11 = null;
double[] m22 = null;
double[] m12 = null;
double[] mMax = null;
double[] mMin = null;
double[] mAngle = null;
double[] v13 = null;
double[] v23 = null;
double[] vMax = null;
double[] vAngle = null;
if (smoothing == MeshResultSmoothingType.ByPanel)
{
Engine.Reflection.Compute.RecordWarning("Force values have been smoothed outside the API by averaging all force values in each node");
}
for (int i = 0; i < panelIds.Count; i++)
{
List <MeshForce> forces = new List <MeshForce>();
int ret = m_model.Results.AreaForceShell(panelIds[i],
eItemTypeElm.ObjectElm,
ref resultCount,
ref obj,
ref elm,
ref pointElm,
ref loadCase,
ref stepType,
ref stepNum,
ref f11,
ref f22,
ref f12,
ref fMax,
ref fMin,
ref fAngle,
ref fvm,
ref m11,
ref m22,
ref m12,
ref mMax,
ref mMin,
ref mAngle,
ref v13,
ref v23,
ref vMax,
ref vAngle);
for (int j = 0; j < resultCount; j++)
{
double step = 0;
if (stepType[j] == "Single Value" || stepNum.Length < j)
{
step = 0;
}
else
{
/***************************************************/
//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 method - Extraction methods ****/
/***************************************************/
private List <MeshResult> ReadMeshForce(List <string> panelIds, MeshResultSmoothingType smoothing)
{
switch (smoothing)
{
case MeshResultSmoothingType.BySelection:
case MeshResultSmoothingType.Global:
case MeshResultSmoothingType.ByFiniteElementCentres:
Engine.Base.Compute.RecordWarning("Smoothing type not supported for MeshForce. No results extracted");
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[] f11 = null;
double[] f22 = null;
double[] f12 = null;
double[] fMax = null;
double[] fMin = null;
double[] fAngle = null;
double[] fvm = null;
double[] m11 = null;
double[] m22 = null;
double[] m12 = null;
double[] mMax = null;
double[] mMin = null;
double[] mAngle = null;
double[] v13 = null;
double[] v23 = null;
double[] vMax = null;
double[] vAngle = null;
List <MeshResult> results = new List <MeshResult>();
if (smoothing == MeshResultSmoothingType.ByPanel)
{
Engine.Base.Compute.RecordWarning("Force values have been smoothed outside the API by averaging all force values in each node");
}
for (int i = 0; i < panelIds.Count; i++)
{
List <MeshForce> forces = new List <MeshForce>();
int ret = m_model.Results.AreaForceShell(panelIds[i], itemTypeElm, ref resultCount, ref obj, ref elm,
ref pointElm, ref loadCase, ref stepType, ref stepNum, ref f11, ref f22, ref f12, ref fMax, ref fMin, ref fAngle, ref fvm,
ref m11, ref m22, ref m12, ref mMax, ref mMin, ref mAngle, ref v13, ref v23, ref vMax, ref vAngle);
for (int j = 0; j < resultCount; j++)
{
int mode;
double timeStep;
if (stepType[j] == "Single Value" || stepNum.Length < j)
{
mode = 0;
timeStep = 0;
}
else
{
GetStepAndMode(stepType[j], stepNum[j], out timeStep, out mode);
}
MeshForce pf = new MeshForce(panelIds[i], pointElm[j], elm[j], loadCase[j], mode, timeStep, 0, 0, 0,
oM.Geometry.Basis.XY, f11[j], f22[j], f12[j], m11[j], m22[j], m12[j], v13[j], v23[j]);
forces.Add(pf);
}
if (smoothing == MeshResultSmoothingType.ByPanel)
{
forces = SmoothenForces(forces);
}
results.AddRange(GroupMeshResults(forces));
}
return(results);
}
private static RenderMesh DisplayMeshResults <TNode, TFace, TMeshElementResult>(this IMesh <TNode, TFace> mesh, IMeshResult <TMeshElementResult> meshResult, Type identifier,
string meshResultDisplay, Gradient gradient, double from, double to)
where TNode : INode
where TFace : IFace
where TMeshElementResult : IMeshElementResult
{
if (mesh?.Nodes == null || mesh?.Faces == null || mesh.Nodes.Count < 1 || mesh.Faces.Count < 1)
{
Engine.Reflection.Compute.RecordError("A mesh is null or invalid. Cannot display results for this mesh.");
return(null);
}
if (meshResult?.Results == null || meshResult.Results.Count < 1)
{
Engine.Reflection.Compute.RecordError("A result is null or invalid. Cannot display results for this mesh.");
return(null);
}
// Order the MeshNodeResults by the IMesh Nodes
List <List <TMeshElementResult> > tempMappedElementResults = mesh.Nodes.MapResults(meshResult.Results, "NodeId", identifier);
// Get the relevant values into a list
List <Vertex> verts = new List <Vertex>();
List <Face> faces;
object smoothing = Reflection.Query.PropertyValue(meshResult, "Smoothing");
MeshResultSmoothingType smoothingType = MeshResultSmoothingType.None;
if (smoothing is MeshResultSmoothingType)
{
smoothingType = (MeshResultSmoothingType)smoothing;
}
switch (smoothingType)
{
case MeshResultSmoothingType.None:
// pair nodeValue as list<Dictionary<FaceId,nodeValue>>
// all nodes are expected to have FaceIds
List <Dictionary <IComparable, double> > nodeValuePairs = tempMappedElementResults.Select(x => x.ToDictionary(y => y.MeshFaceId, y => /*propFunction(y)*/ y.ResultToValue(meshResultDisplay))).ToList();
// put the Faces in a Dictionary<FaceId,Face>
Dictionary <object, Face> faceDictionaryResult = mesh.Faces.ToDictionary(x => x.FindFragment <IAdapterId>(identifier).Id, x => x.Geometry());
Dictionary <object, Face> faceDictionaryRefrence = mesh.Faces.ToDictionary(x => x.FindFragment <IAdapterId>(identifier).Id, x => x.Geometry());
// Add all verticies to a list with their colour and update the Faces
for (int k = 0; k < mesh.Nodes.Count; k++)
{
foreach (KeyValuePair <IComparable, double> FaceRelatedValue in nodeValuePairs[k])
{
verts.Add(new Vertex()
{
Point = mesh.Nodes[k].Position,
Color = gradient.Color(FaceRelatedValue.Value, from, to)
});
// Face management, faceResult points to verts and faceReference points to mesh.Nodes
Face faceResult = faceDictionaryResult[FaceRelatedValue.Key];
Face faceReference = faceDictionaryRefrence[FaceRelatedValue.Key];
Face newFace = new Face()
{
A = faceReference.A == k ? verts.Count - 1 : faceResult.A,
B = faceReference.B == k ? verts.Count - 1 : faceResult.B,
C = faceReference.C == k ? verts.Count - 1 : faceResult.C,
D = faceReference.IsQuad() ? faceReference.D == k ? verts.Count - 1 : faceResult.D : -1
};
faceDictionaryResult[FaceRelatedValue.Key] = newFace;
}
}
faces = faceDictionaryResult.Select(x => x.Value).ToList();
break;
case MeshResultSmoothingType.ByPanel:
case MeshResultSmoothingType.Global:
List <double> nodeValues = tempMappedElementResults.Select(x => x[0].ResultToValue(meshResultDisplay)).ToList();
// Add all verticies to a list with their colour
for (int k = 0; k < mesh.Nodes.Count; k++)
{
verts.Add(new Vertex()
{
Point = mesh.Nodes[k].Position,
Color = gradient.Color(nodeValues[k], from, to)
});
}
faces = mesh.Faces.Geometry().ToList();
break;
case MeshResultSmoothingType.ByFiniteElementCentres:
case MeshResultSmoothingType.BySelection:
default:
Engine.Reflection.Compute.RecordError("Unsupported SmoothingType: " + Reflection.Query.PropertyValue(meshResult, "Smoothing").ToString() +
" detected, meshResult for ObjectId: " + meshResult.ObjectId.ToString() +
" and ResultCase: " + meshResult.ResultCase.ToString() + "will be returned empty.");
return(new RenderMesh());
}
return(new RenderMesh()
{
Vertices = verts, Faces = faces
});
}
public static MeshResultRequest MeshResultRequest(MeshResultType resultType = MeshResultType.Forces, MeshResultSmoothingType smoothing = MeshResultSmoothingType.None, MeshResultLayer layer = MeshResultLayer.AbsoluteMaximum, double layerPosition = 0, Basis orientation = null, List <object> cases = null, List <string> modes = null, List <object> objectIds = null)
{
return(new MeshResultRequest
{
ResultType = resultType,
Smoothing = smoothing,
Layer = layer,
LayerPosition = layerPosition,
Orientation = orientation,
Cases = cases ?? new List <object>(),
Modes = modes ?? new List <string>(),
ObjectIds = objectIds ?? new List <object>()
});
}
/***************************************************/
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);
}
