GetConstraint(this cPointElm obj, string Name, eItemTypeElm ItemTypeElm = eItemTypeElm.Element)
{
int NumberItems;
NumberItems = default(int);
string[] PointName, ConstraintName;
PointName = ConstraintName = default(string[]);
var res = obj.GetConstraint(Name, ref NumberItems, ref PointName, ref ConstraintName, ItemTypeElm);
return(NumberItems, PointName, ConstraintName);
}
LinkJointForce(this cAnalysisResults obj, string Name, eItemTypeElm ItemTypeElm)
{
int NumberResults;
NumberResults = default(int);
string[] Obj, Elm, PointElm, LoadCase, StepType;
Obj = Elm = PointElm = LoadCase = StepType = default(string[]);
double[] StepNum, F1, F2, F3, M1, M2, M3;
StepNum = F1 = F2 = F3 = M1 = M2 = M3 = default(double[]);
var res = obj.LinkJointForce(Name, ItemTypeElm, ref NumberResults, ref Obj, ref Elm, ref PointElm, ref LoadCase, ref StepType, ref StepNum, ref F1, ref F2, ref F3, ref M1, ref M2, ref M3);
return(NumberResults, Obj, Elm, PointElm, LoadCase, StepType, StepNum, F1, F2, F3, M1, M2, M3);
}
PanelZoneDeformation(this cAnalysisResults obj, string Name, eItemTypeElm ItemTypeElm)
{
int NumberResults;
NumberResults = default(int);
string[] Elm, LoadCase, StepType;
Elm = LoadCase = StepType = default(string[]);
double[] StepNum, U1, U2, U3, R1, R2, R3;
StepNum = U1 = U2 = U3 = R1 = R2 = R3 = default(double[]);
var res = obj.PanelZoneDeformation(Name, ItemTypeElm, ref NumberResults, ref Elm, ref LoadCase, ref StepType, ref StepNum, ref U1, ref U2, ref U3, ref R1, ref R2, ref R3);
return(NumberResults, Elm, LoadCase, StepType, StepNum, U1, U2, U3, R1, R2, R3);
}
FrameForce(this cAnalysisResults obj, string Name, eItemTypeElm ItemTypeElm)
{
int NumberResults;
NumberResults = default(int);
string[] Obj, Elm, LoadCase, StepType;
Obj = Elm = LoadCase = StepType = default(string[]);
double[] ObjSta, ElmSta, StepNum, P, V2, V3, T, M2, M3;
ObjSta = ElmSta = StepNum = P = V2 = V3 = T = M2 = M3 = default(double[]);
var res = obj.FrameForce(Name, ItemTypeElm, ref NumberResults, ref Obj, ref ObjSta, ref Elm, ref ElmSta, ref LoadCase, ref StepType, ref StepNum, ref P, ref V2, ref V3, ref T, ref M2, ref M3);
return(NumberResults, Obj, ObjSta, Elm, ElmSta, LoadCase, StepType, StepNum, P, V2, V3, T, M2, M3);
}
PanelZoneForce(this cAnalysisResults obj, string Name, eItemTypeElm ItemTypeElm)
{
int NumberResults;
NumberResults = default(int);
string[] Elm, PointElm, LoadCase, StepType;
Elm = PointElm = LoadCase = StepType = default(string[]);
double[] StepNum, P, V2, V3, T, M2, M3;
StepNum = P = V2 = V3 = T = M2 = M3 = default(double[]);
var res = obj.PanelZoneForce(Name, ItemTypeElm, ref NumberResults, ref Elm, ref PointElm, ref LoadCase, ref StepType, ref StepNum, ref P, ref V2, ref V3, ref T, ref M2, ref M3);
return(NumberResults, Elm, PointElm, LoadCase, StepType, StepNum, P, V2, V3, T, M2, M3);
}
AssembledJointMass(this cAnalysisResults obj, string Name, eItemTypeElm ItemTypeElm)
{
int NumberResults;
NumberResults = default(int);
string[] PointElm;
PointElm = default(string[]);
double[] U1, U2, U3, R1, R2, R3;
U1 = U2 = U3 = R1 = R2 = R3 = default(double[]);
var res = obj.AssembledJointMass(Name, ItemTypeElm, ref NumberResults, ref PointElm, ref U1, ref U2, ref U3, ref R1, ref R2, ref R3);
return(NumberResults, PointElm, U1, U2, U3, R1, R2, R3);
}
AreaForceShell(this cAnalysisResults obj, string Name, eItemTypeElm ItemTypeElm)
{
int NumberResults;
NumberResults = default(int);
string[] Obj, Elm, PointElm, LoadCase, StepType;
Obj = Elm = PointElm = LoadCase = StepType = default(string[]);
double[] StepNum, F11, F22, F12, FMax, FMin, FAngle, FVM, M11, M22, M12, MMax, MMin, MAngle, V13, V23, VMax, VAngle;
StepNum = F11 = F22 = F12 = FMax = FMin = FAngle = FVM = M11 = M22 = M12 = MMax = MMin = MAngle = V13 = V23 = VMax = VAngle = default(double[]);
var res = obj.AreaForceShell(Name, ItemTypeElm, ref NumberResults, 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);
return(NumberResults, Obj, Elm, PointElm, LoadCase, StepType, StepNum, F11, F22, F12, FMax, FMin, FAngle, FVM, M11, M22, M12, MMax, MMin, MAngle, V13, V23, VMax, VAngle);
}
AreaStressShell(this cAnalysisResults obj, string Name, eItemTypeElm ItemTypeElm)
{
int NumberResults;
NumberResults = default(int);
string[] Obj, Elm, PointElm, LoadCase, StepType;
Obj = Elm = PointElm = LoadCase = StepType = default(string[]);
double[] StepNum, S11Top, S22Top, S12Top, SMaxTop, SMinTop, SAngleTop, SVMTop, S11Bot, S22Bot, S12Bot, SMaxBot, SMinBot, SAngleBot, SVMBot, S13Avg, S23Avg, SMaxAvg, SAngleAvg;
StepNum = S11Top = S22Top = S12Top = SMaxTop = SMinTop = SAngleTop = SVMTop = S11Bot = S22Bot = S12Bot = SMaxBot = SMinBot = SAngleBot = SVMBot = S13Avg = S23Avg = SMaxAvg = SAngleAvg = default(double[]);
var res = obj.AreaStressShell(Name, ItemTypeElm, ref NumberResults, ref Obj, ref Elm, ref PointElm, ref LoadCase, ref StepType, ref StepNum, ref S11Top, ref S22Top, ref S12Top, ref SMaxTop, ref SMinTop, ref SAngleTop, ref SVMTop, ref S11Bot, ref S22Bot, ref S12Bot, ref SMaxBot, ref SMinBot, ref SAngleBot, ref SVMBot, ref S13Avg, ref S23Avg, ref SMaxAvg, ref SAngleAvg);
return(NumberResults, Obj, Elm, PointElm, LoadCase, StepType, StepNum, S11Top, S22Top, S12Top, SMaxTop, SMinTop, SAngleTop, SVMTop, S11Bot, S22Bot, S12Bot, SMaxBot, SMinBot, SAngleBot, SVMBot, S13Avg, S23Avg, SMaxAvg, SAngleAvg);
}
JointDisplAbs(this cAnalysisResults obj, string Name, eItemTypeElm ItemTypeElm)
{
int NumberResults;
NumberResults = default(int);
string[] Obj, Elm, LoadCase, StepType;
Obj = Elm = LoadCase = StepType = default(string[]);
double[] StepNum, U1, U2, U3, R1, R2, R3;
StepNum = U1 = U2 = U3 = R1 = R2 = R3 = default(double[]);
var res = obj.JointDisplAbs(Name, ItemTypeElm, ref NumberResults, ref Obj, ref Elm, ref LoadCase, ref StepType, ref StepNum, ref U1, ref U2, ref U3, ref R1, ref R2, ref R3);
return(NumberResults, Obj, Elm, LoadCase, StepType, StepNum, U1, U2, U3, R1, R2, R3);
}
GetLoadForce(this cPointElm obj, string Name, eItemTypeElm ItemTypeElm = eItemTypeElm.Element)
{
int NumberItems;
NumberItems = default(int);
string[] PointName, LoadPat, CSys;
PointName = LoadPat = CSys = default(string[]);
int[] LcStep;
LcStep = default(int[]);
double[] F1, F2, F3, M1, M2, M3;
F1 = F2 = F3 = M1 = M2 = M3 = default(double[]);
var res = obj.GetLoadForce(Name, ref NumberItems, ref PointName, ref LoadPat, ref LcStep, ref CSys, ref F1, ref F2, ref F3, ref M1, ref M2, ref M3, ItemTypeElm);
return(NumberItems, PointName, LoadPat, LcStep, CSys, F1, F2, F3, M1, M2, M3);
}
GetLoadDispl(this cPointElm obj, string Name, eItemTypeElm ItemTypeElm = eItemTypeElm.Element)
{
int NumberItems;
NumberItems = default(int);
string[] PointName, LoadPat, CSys;
PointName = LoadPat = CSys = default(string[]);
int[] LcStep;
LcStep = default(int[]);
double[] U1, U2, U3, R1, R2, R3;
U1 = U2 = U3 = R1 = R2 = R3 = default(double[]);
var res = obj.GetLoadDispl(Name, ref NumberItems, ref PointName, ref LoadPat, ref LcStep, ref CSys, ref U1, ref U2, ref U3, ref R1, ref R2, ref R3, ItemTypeElm);
return(NumberItems, PointName, LoadPat, LcStep, CSys, U1, U2, U3, R1, R2, R3);
}
GetLoadUniform(this cAreaElm obj, string Name, eItemTypeElm ItemTypeElm = eItemTypeElm.Element)
{
int NumberItems;
NumberItems = default(int);
string[] AreaName, LoadPat, CSys;
AreaName = LoadPat = CSys = default(string[]);
int[] Dir;
Dir = default(int[]);
double[] Value;
Value = default(double[]);
var res = obj.GetLoadUniform(Name, ref NumberItems, ref AreaName, ref LoadPat, ref CSys, ref Dir, ref Value, ItemTypeElm);
return(NumberItems, AreaName, LoadPat, CSys, Dir, Value);
}
GetLoadTemperature(this cLineElm obj, string Name, eItemTypeElm ItemTypeElm = eItemTypeElm.Element)
{
int NumberItems;
NumberItems = default(int);
string[] LineName, LoadPat, PatternName;
LineName = LoadPat = PatternName = default(string[]);
int[] MyType;
MyType = default(int[]);
double[] Val;
Val = default(double[]);
var res = obj.GetLoadTemperature(Name, ref NumberItems, ref LineName, ref LoadPat, ref MyType, ref Val, ref PatternName, ItemTypeElm);
return(NumberItems, LineName, LoadPat, MyType, Val, PatternName);
}
GetLoadDistributed(this cLineElm obj, string Name, eItemTypeElm ItemTypeElm = eItemTypeElm.Element)
{
int NumberItems;
NumberItems = default(int);
string[] LineName, LoadPat, CSys;
LineName = LoadPat = CSys = default(string[]);
int[] MyType, Dir;
MyType = Dir = default(int[]);
double[] RD1, RD2, Dist1, Dist2, Val1, Val2;
RD1 = RD2 = Dist1 = Dist2 = Val1 = Val2 = default(double[]);
var res = obj.GetLoadDistributed(Name, ref NumberItems, ref LineName, ref LoadPat, ref MyType, ref CSys, ref Dir, ref RD1, ref RD2, ref Dist1, ref Dist2, ref Val1, ref Val2, ItemTypeElm);
return(NumberItems, LineName, LoadPat, MyType, CSys, Dir, RD1, RD2, Dist1, Dist2, Val1, Val2);
}
GetLoadPoint(this cLineElm obj, string Name, eItemTypeElm ItemTypeElm = eItemTypeElm.Element)
{
int NumberItems;
NumberItems = default(int);
string[] LineName, LoadPat, CSys;
LineName = LoadPat = CSys = default(string[]);
int[] MyType, Dir;
MyType = Dir = default(int[]);
double[] RelDist, Dist, Val;
RelDist = Dist = Val = default(double[]);
var res = obj.GetLoadPoint(Name, ref NumberItems, ref LineName, ref LoadPat, ref MyType, ref CSys, ref Dir, ref RelDist, ref Dist, ref Val, ItemTypeElm);
return(NumberItems, LineName, LoadPat, MyType, CSys, Dir, RelDist, Dist, Val);
}
AreaStressShellLayered(this cAnalysisResults obj, string Name, eItemTypeElm ItemTypeElm)
{
int NumberResults;
NumberResults = default(int);
string[] Obj, Elm, Layer, PointElm, LoadCase, StepType;
Obj = Elm = Layer = PointElm = LoadCase = StepType = default(string[]);
int[] IntPtNum;
IntPtNum = default(int[]);
double[] IntPtLoc, StepNum, S11, S22, S12, SMax, SMin, SAngle, SVM, S13Avg, S23Avg, SMaxAvg, SAngleAvg;
IntPtLoc = StepNum = S11 = S22 = S12 = SMax = SMin = SAngle = SVM = S13Avg = S23Avg = SMaxAvg = SAngleAvg = default(double[]);
var res = obj.AreaStressShellLayered(Name, ItemTypeElm, ref NumberResults, ref Obj, ref Elm, ref Layer, ref IntPtNum, ref IntPtLoc, ref PointElm, ref LoadCase, ref StepType, ref StepNum, ref S11, ref S22, ref S12, ref SMax, ref SMin, ref SAngle, ref SVM, ref S13Avg, ref S23Avg, ref SMaxAvg, ref SAngleAvg);
return(NumberResults, Obj, Elm, Layer, IntPtNum, IntPtLoc, PointElm, LoadCase, StepType, StepNum, S11, S22, S12, SMax, SMin, SAngle, SVM, S13Avg, S23Avg, SMaxAvg, SAngleAvg);
}
/***************************************************/
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);
}
/***************************************************/
/**** 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);
}
public static List<MeshForce> GetMeshForce(cSapModel model, IList ids = null, IList cases = null, int divisions = 5)
{
List<string> loadcaseIds = new List<string>();
List<string> panelIds = new List<string>();
List<MeshForce> meshForces = new List<MeshForce>();
if (ids == null)
{
int panels = 0;
string[] names = null;
model.AreaObj.GetNameList(ref panels, ref names);
panelIds = names.ToList();
}
else
{
for (int i = 0; i < ids.Count; i++)
{
panelIds.Add(ids[i].ToString());
}
}
//Get out loadcases, get all for null list
loadcaseIds = CheckAndGetCases(model, cases);
string Name = "";
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;
for (int i = 0; i < panelIds.Count; i++)
{
int ret = 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++)
{
MeshForce pf = new MeshForce(panelIds[i], PointElm[j], "", LoadCase[j], StepNum[j], 0, 0, 0,
oM.Geometry.Basis.XY, F11[j], F22[j], F12[j], M12[j], M22[j], M12[j], V13[j], V23[j]);
meshForces.Add(pf);
}
}
return meshForces;
}
private List <FramePointResult> GetFrameForceList(string ComboName, ForceType ForceType)
{
EtabsModel.Results.Setup.DeselectAllCasesAndCombosForOutput();
var ret1 = EtabsModel.Results.Setup.SetComboSelectedForOutput(ComboName);
int NumberResults = 0;
string[] _Obj = null;
double[] _ObjSta = null;
string[] _Elm = null;
double[] _ElmSta = null;
string[] _LoadCase = null;
string[] _StepType = null;
double[] _StepNum = null;
double[] _P = null;
double[] _V2 = null;
double[] _V3 = null;
double[] _T = null;
double[] _M2 = null;
double[] _M3 = null;
eItemTypeElm elementType = eItemTypeElm.ObjectElm;
var ret2 = EtabsModel.Results.FrameForce(this.Name, elementType,
ref NumberResults,
ref _Obj,
ref _ObjSta,
ref _Elm,
ref _ElmSta,
ref _LoadCase,
ref _StepType,
ref _StepNum,
ref _P,
ref _V2,
ref _V3,
ref _T,
ref _M2,
ref _M3);
List <FramePointResult> outputList = new List <FramePointResult>();
if (NumberResults > 0)
{
List <double> Values = new List <double>();
List <double> Stations = ArrayToListConverter.Convert <double>(_ObjSta);
switch (ForceType)
{
case ForceType.Fx:
Values = ArrayToListConverter.Convert <double>(_P);
break;
case ForceType.Fy:
Values = ArrayToListConverter.Convert <double>(_V2);
break;
case ForceType.Fz:
Values = ArrayToListConverter.Convert <double>(_V3);
break;
case ForceType.Mx:
Values = ArrayToListConverter.Convert <double>(_T);
break;
case ForceType.My:
Values = ArrayToListConverter.Convert <double>(_M2);
break;
case ForceType.Mz:
Values = ArrayToListConverter.Convert <double>(_M3);
break;
}
for (int i = 0; i < Values.Count; i++)
{
outputList.Add(new FramePointResult()
{
ResultValue = Values[i], Station = Stations[i]
});
}
}
return(outputList);
}
/***************************************************/
//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);
}
