/***************************************************/
/**** Public method - Read override ****/
/***************************************************/
public IEnumerable <IResult> ReadResults(NodeResultRequest request, ActionConfig actionConfig)
{
List <IResult> results;
List <int> objectIds = GetObjectIDs(request);
List <int> loadCases = GetLoadcaseIDs(request);
switch (request.ResultType)
{
case NodeResultType.NodeReaction:
results = ExtractNodeReaction(objectIds, loadCases).ToList();
break;
case NodeResultType.NodeDisplacement:
results = ExtractNodeDisplacement(objectIds, loadCases).ToList();
break;
default:
Engine.Base.Compute.RecordError($"Result of type {request.ResultType} is not yet supported in the Lusas_Toolkit.");
results = new List <IResult>();
break;
}
results.Sort();
return(results);
}
/***************************************************/
private List <string> CheckGetNodeIds(NodeResultRequest request)
{
int sapNodeCount = 0;
string[] sapNodeIds = null;
m_model.PointObj.GetNameList(ref sapNodeCount, ref sapNodeIds);
return(FilterIds(request.ObjectIds.Select(x => x.ToString()), sapNodeIds));
}
/***************************************************/
/**** Private method - Support methods ****/
/***************************************************/
private List <string> CheckGetNodeIds(NodeResultRequest request)
{
List <string> nodeIds = CheckAndGetIds <Node>(request.ObjectIds);
if (nodeIds == null || nodeIds.Count == 0)
{
int nodes = 0;
string[] names = null;
m_model.PointObj.GetNameList(ref nodes, ref names);
nodeIds = names.ToList();
}
return(nodeIds);
}
private List <int> GetAllIds(NodeResultRequest request)
{
List <int> ids = new List <int>();
int maxIndex = d_LusasData.getLargestNodeID();
for (int i = 1; i < maxIndex + 1; i++)
{
if (d_LusasData.existsPointByID(i))
{
ids.Add(
System.Convert.ToInt32(
d_LusasData.getPointByNumber(i).getID().ToString()));
}
}
return(ids);
}
/***************************************************/
/**** Public method - Read override ****/
/***************************************************/
public IEnumerable <IResult> ReadResults(NodeResultRequest request, ActionConfig actionConfig = null)
{
CheckAndSetUpCases(request);
List <string> nodeIds = CheckGetNodeIds(request);
switch (request.ResultType)
{
case NodeResultType.NodeReaction:
return(ReadNodeReaction(nodeIds));
case NodeResultType.NodeDisplacement:
return(ReadNodeDisplacement(nodeIds));
case NodeResultType.NodeVelocity:
case NodeResultType.NodeAcceleration:
default:
Engine.Base.Compute.RecordError("Result extraction of type " + request.ResultType + " is not yet supported");
return(new List <IResult>());
}
}
public static IResultRequest IResultRequest(Type type, IEnumerable <object> ids = null, IEnumerable <object> cases = null, int divisions = 5)
{
IResultRequest request = null;
if (typeof(BarResult).IsAssignableFrom(type))
{
BarResultType resType = BarResultType.BarForce;
if (type == typeof(BarForce))
{
resType = BarResultType.BarForce;
}
else if (type == typeof(BarDeformation))
{
resType = BarResultType.BarDeformation;
}
else if (type == typeof(BarStress))
{
resType = BarResultType.BarStress;
}
else if (type == typeof(BarStrain))
{
resType = BarResultType.BarStrain;
}
else if (type == typeof(BarDisplacement))
{
resType = BarResultType.BarDisplacement;
}
else if (type == typeof(BarModeShape))
{
resType = BarResultType.BarModeShape;
}
else
{
Reflection.Compute.RecordWarning("Did not find exact type. Assuming " + resType);
}
request = new BarResultRequest {
Divisions = divisions, DivisionType = DivisionType.EvenlyDistributed, ResultType = resType
};
}
else if (typeof(MeshResult).IsAssignableFrom(type) || typeof(MeshElementResult).IsAssignableFrom(type))
{
MeshResultType resType = MeshResultType.Forces;
if (type == typeof(MeshForce))
{
resType = MeshResultType.Forces;
}
else if (type == typeof(MeshStress))
{
resType = MeshResultType.Stresses;
}
else if (type == typeof(MeshVonMises))
{
resType = MeshResultType.VonMises;
}
else if (type == typeof(MeshDisplacement))
{
resType = MeshResultType.Displacements;
}
else if (type == typeof(MeshModeShape))
{
resType = MeshResultType.MeshModeShape;
}
else
{
Reflection.Compute.RecordWarning("Did not find exact type. Assuming " + resType);
}
request = new MeshResultRequest {
ResultType = resType
};
}
else if (typeof(StructuralGlobalResult).IsAssignableFrom(type))
{
GlobalResultType resType = GlobalResultType.Reactions;
if (type == typeof(GlobalReactions))
{
resType = GlobalResultType.Reactions;
}
else if (type == typeof(ModalDynamics))
{
resType = GlobalResultType.ModalDynamics;
}
else
{
Reflection.Compute.RecordWarning("Did not find exact type. Assuming " + resType);
}
request = new GlobalResultRequest {
ResultType = resType
};
}
else if (typeof(NodeResult).IsAssignableFrom(type))
{
NodeResultType resType = NodeResultType.NodeReaction;
if (type == typeof(NodeReaction))
{
resType = NodeResultType.NodeReaction;
}
else if (type == typeof(NodeDisplacement))
{
resType = NodeResultType.NodeDisplacement;
}
else if (type == typeof(NodeAcceleration))
{
resType = NodeResultType.NodeAcceleration;
}
else if (type == typeof(NodeVelocity))
{
resType = NodeResultType.NodeVelocity;
}
else if (type == typeof(NodeModalMass))
{
resType = NodeResultType.NodeModalMass;
}
else if (type == typeof(NodeModeShape))
{
resType = NodeResultType.NodeModeShape;
}
else
{
Reflection.Compute.RecordWarning("Did not find exact type. Assuming " + resType);
}
request = new NodeResultRequest {
ResultType = resType
};
}
else
{
return(null);
}
if (ids != null)
{
request.ObjectIds = ids.ToList();
}
if (cases != null)
{
request.Cases = cases.ToList();
}
return(request);
}
