/***************************************************/
/***************************************************/
/**** 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;
}
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);
}
/***************************************************/
/***************************************************/
/**** 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;
}
/***************************************************/
/***************************************************/
/**** 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 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 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 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 ****/
/***************************************************/
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 ****/
/***************************************************/
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 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);
}
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 IEnumerable <IResult> ExtractMeshVonMises(List <int> ids, List <int> loadcaseIds, MeshResultLayer meshResultLayer)
{
List <MeshVonMises> meshStresses = new List <MeshVonMises>();
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>()
{
"SE"
};
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 sE = 0;
featureResults.TryGetValue("SE", out sE);
int mode = -1;
MeshVonMises meshStress = new MeshVonMises(
meshId, 0, 0, loadcaseId, mode, 0, MeshResultLayer.Middle, 0.5, MeshResultSmoothingType.ByPanel, null,
sE * forceSIConversion / (lengthSIConversion * lengthSIConversion), 0, 0);
meshStresses.Add(meshStress);
}
d_LusasData.stopUsingScriptedResults();
d_LusasData.flushScriptedResults();
}
return(meshStresses);
}
