/***************************************************/
private List <int> GetLoadcaseIDs(IResultRequest request)
{
IList cases = request.Cases;
List <int> caseNums = new List <int>();
if (cases is List <string> )
{
return((cases as List <string>).Select(x => int.Parse(x)).ToList());
}
else if (cases is List <int> )
{
return(cases as List <int>);
}
else if (cases is List <double> )
{
return((cases as List <double>).Select(x => (int)Math.Round(x)).ToList());
}
else if (cases is List <Loadcase> )
{
for (int i = 0; i < cases.Count; i++)
{
caseNums.Add(System.Convert.ToInt32((cases[i] as Loadcase).Number));
}
}
else if (cases is List <LoadCombination> )
{
foreach (object lComb in cases)
{
foreach (Tuple <double, ICase> lCase in (lComb as LoadCombination).LoadCases)
{
caseNums.Add(System.Convert.ToInt32(lCase.Item2.Number));
}
caseNums.Add((lComb as LoadCombination).AdapterId <int>(typeof(LusasId)));
}
}
else
{
List <int> idsOut = new List <int>();
foreach (object o in cases)
{
int id;
if (int.TryParse(o.ToString(), out id))
{
idsOut.Add(id);
}
}
return(idsOut);
}
return(caseNums);
}
/***************************************************/
/**** Private Methods - Index checking ****/
/***************************************************/
private List <int> GetObjectIDs(IResultRequest request)
{
IList ids = request.ObjectIds;
if (ids == null || ids.Count == 0)
{
return(GetAllIds(request as dynamic));
}
else
{
if (ids is List <string> )
{
return((ids as List <string>).Select(x => int.Parse(x)).ToList());
}
else if (ids is List <int> )
{
return(ids as List <int>);
}
else if (ids is List <double> )
{
return((ids as List <double>).Select(x => (int)Math.Round(x)).ToList());
}
else
{
List <int> idsOut = new List <int>();
foreach (object o in ids)
{
int id;
if (int.TryParse(o.ToString(), out id))
{
idsOut.Add(id);
}
else if (o is IBHoMObject && (o as IBHoMObject).HasAdapterIdFragment(typeof(LusasId)))
{
int.TryParse((o as IBHoMObject).AdapterId <string>(typeof(LusasId)), out id);
idsOut.Add(id);
}
}
return(idsOut);
}
}
}
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);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private List <string> CheckAndSetUpCases(IResultRequest request)
{
return(CheckAndSetUpCases(request.Cases));
}
