public override void TraverseTestBench(CyPhy.TestBenchType testBenchBase)
{
string stepFormat = "AP203_E2_Single_File";
if (!DataExchangeFormats.Contains(stepFormat))
DataExchangeFormats.Add(stepFormat);
CyPhy.CADTestBench testBench = testBenchBase as CyPhy.CADTestBench;
if (testBench == null)
testBench = CyPhyClasses.CADTestBench.Cast(testBenchBase.Impl);
this.CyphyTestBenchRef = testBench;
base.TraverseTestBench(testBenchBase);
AdjSurfTreatment = CyphyTestBenchRef.Attributes.AdjoiningTreatment;
// Solver Settings
ElementType = "MIDPOINT_PARABOLIC_FIXED";
ShellType = "N/A";
SolverType = testBench.Attributes.SolverType.ToString();
MeshType = "SOLID";
MaxAdaptiveIterations = testBench.Attributes.MaxAdaptiveIterations;
FEAAnalysisType = "STRUCTURAL";
if (testBench.Children.ThermalLoadCollection.Any() || testBench.Children.ThermalEnvironmentCollection.Any())
{
FEAAnalysisType = "THERMAL";
}
// Metrics
foreach (var item in testBench.Children.TIP2StructuralMetricCollection)
{
if (item.SrcEnds.TestInjectionPoint != null)
{
CyPhy.TestInjectionPoint tip = item.SrcEnds.TestInjectionPoint;
CyPhy.StructuralFEAComputation feaComp = item.DstEnds.StructuralFEAComputation;
if (tip.AllReferred == null)
continue;
List<CyPhy.Component> testComponents = new List<CyPhy.Component>();
if (tip.AllReferred is CyPhy.ComponentAssembly)
{
CollectLeafComponents(testComponents, tip.AllReferred as CyPhy.ComponentAssembly);
}
else if (tip.AllReferred is CyPhy.Component)
{
// Interested in components with CAD Model only
if ((tip.AllReferred as CyPhy.Component).Children.CADModelCollection.Any())
testComponents.Add(tip.AllReferred as CyPhy.Component);
}
foreach (CyPhy.Component comp in testComponents)
{
string compId = comp.Attributes.InstanceGUID;
foreach (var cyphycompport in feaComp.Children.StructuralAnalysisComputationTypeCollection)
{
TBComputation tbcomputation = new TBComputation();
if (cyphycompport is CyPhy.BearingStress)
{
tbcomputation.ComputationType = TBComputation.Type.BEARINGSTRESS;
} else if (cyphycompport is CyPhy.MisesStress)
{
tbcomputation.ComputationType = TBComputation.Type.VONMISESSTRESS;
} else if (cyphycompport is CyPhy.ShearStress)
{
tbcomputation.ComputationType = TBComputation.Type.SHEARSTRESS;
} else if (cyphycompport is CyPhy.MaximumDisplacement)
{
tbcomputation.ComputationType = TBComputation.Type.DISPLACEMENT;
} else if (cyphycompport is CyPhy.FactorOfSafety)
{
tbcomputation.ComputationType = TBComputation.Type.FACTOROFSAFETY;
}
tbcomputation.FeatureDatumName = "";
tbcomputation.RequestedValueType = "Scalar";
tbcomputation.Details = "InfiniteCycle";
tbcomputation.ComponentID = compId;
foreach (var cyphyconn in cyphycompport.DstConnections.FEAComputation2MetricCollection)
{
tbcomputation.MetricID = cyphyconn.DstEnds.Metric.ID;
}
if (!String.IsNullOrEmpty(tbcomputation.MetricID))
this.Computations.Add(tbcomputation);
}
}
}
}
// Thermal Metrics
foreach (var item in testBench.Children.TIP2ThermalMetricCollection)
{
if (item.SrcEnds.TestInjectionPoint != null)
{
CyPhy.TestInjectionPoint tip = item.SrcEnds.TestInjectionPoint;
CyPhy.ThermalFEAComputation feaComp = item.DstEnds.ThermalFEAComputation;
if (tip.AllReferred == null)
continue;
List<CyPhy.Component> testComponents = new List<CyPhy.Component>();
if (tip.AllReferred is CyPhy.ComponentAssembly)
{
CollectLeafComponents(testComponents, tip.AllReferred as CyPhy.ComponentAssembly);
}
else if (tip.AllReferred is CyPhy.Component)
{
// Interested in components with CAD Model only
if ((tip.AllReferred as CyPhy.Component).Children.CADModelCollection.Any())
testComponents.Add(tip.AllReferred as CyPhy.Component);
}
foreach (CyPhy.Component comp in testComponents)
{
string compId = comp.Attributes.InstanceGUID;
foreach (var cyphycompport in feaComp.Children.ThermalAnalysisMetricsCollection)
{
TBComputation tbcomputation = new TBComputation();
if (cyphycompport is CyPhy.MinimumTemperature)
{
tbcomputation.ComputationType = TBComputation.Type.MINIMUMTEMPERATURE;
} else if (cyphycompport is CyPhy.MaximumTemperature)
{
tbcomputation.ComputationType = TBComputation.Type.MAXIMUMTEMPERATURE;
}
tbcomputation.FeatureDatumName = "";
tbcomputation.RequestedValueType = "Scalar";
tbcomputation.Details = "InfiniteCycle";
tbcomputation.ComponentID = compId;
foreach (var cyphyconn in cyphycompport.DstConnections.FEAComputation2MetricCollection)
{
tbcomputation.MetricID = cyphyconn.DstEnds.Metric.ID;
}
if (!String.IsNullOrEmpty(tbcomputation.MetricID))
this.Computations.Add(tbcomputation);
}
}
}
}
bool convectionPresent = false;
bool ambientTempPresent = false;
// thermal elements
foreach(var item in testBench.Children.ThermalFEAElementsCollection)
{
foreach (var conn in item.DstConnections.ThermalElement2TIPCollection)
{
CyPhy.TestInjectionPoint tip = conn.DstEnds.TestInjectionPoint;
if (tip.AllReferred == null)
continue;
List<CyPhy.Component> testComponents = new List<CyPhy.Component>();
if (tip.AllReferred is CyPhy.ComponentAssembly)
{
CollectLeafComponents(testComponents, tip.AllReferred as CyPhy.ComponentAssembly);
}
else if (tip.AllReferred is CyPhy.Component)
{
// Interested in components with CAD Model only
if ((tip.AllReferred as CyPhy.Component).Children.CADModelCollection.Any())
testComponents.Add(tip.AllReferred as CyPhy.Component);
}
foreach (var component in testComponents)
{
FEAThermalElement[] element = FEAThermalElement.Extract(item, component.Attributes.InstanceGUID, null);
if (element.Where(e => e.Type == "Convection").Any())
{
convectionPresent = true;
}
ThermalElements.AddRange(element);
}
}
foreach (var conn in item.DstConnections.ThermalElements2GeometryCollection)
{
CyPhy.GeometryBase geometryBase = conn.DstEnds.GeometryTypes;
string tipContextPath = Path.GetDirectoryName(geometryBase.Path);
CADGeometry geometryRep = FillOutGeometryRep(geometryBase.Impl as MgaFCO,
tipContextPath);
FEAThermalElement[] element = FEAThermalElement.Extract(item, null, geometryRep);
ThermalElements.AddRange(element);
}
}
if (testBench.Children.ThermalEnvironmentCollection.Any())
{
if (testBench.Children.ThermalEnvironmentCollection.Count() > 1)
{
Logger.Instance.AddLogMessage("Multiple ThermalEnvironments are present in the testbench. There should be only one.", Severity.Error);
}
else
{
if (!testBench.Children.ThermalEnvironmentCollection.First().Children.ParameterCollection.Any())
{
Logger.Instance.AddLogMessage("ThermalEnvironment is present but there are no parameters specified in it.", Severity.Warning);
}
else
{
foreach (var param in testBench.Children.ThermalEnvironmentCollection.First().Children.ParameterCollection)
{
var elem = new FEAThermalElement(param) { Unit = "K", ComponentID = cadDataContainer.assemblies.First().Key };
ThermalElements.Add(elem);
ambientTempPresent = true;
}
}
}
}
if (convectionPresent && !ambientTempPresent)
{
Logger.Instance.AddLogMessage("Convection is present but no Ambient Temperature has been specified. Please specify Ambient Temperature.", Severity.Error);
}
// Constraints
foreach (var cyphyconstraint in testBench.Children.AnalysisConstraintCollection)
{
if (cyphyconstraint.Kind == "PinConstraint")
{
CyPhy.PinConstraint pinConstraint = CyPhyClasses.PinConstraint.Cast(cyphyconstraint.Impl);
// Geometry - must be a cylinder
foreach (var geometry in pinConstraint.DstConnections.Pin2CylinderCollection)
{
FEAPinConstraint feapinRep = new FEAPinConstraint();
feapinRep.AxialDisplacement = pinConstraint.Attributes.AxialDisplacement.ToString();
feapinRep.AxialRotation = pinConstraint.Attributes.AxialRotation.ToString();
CyPhy.CylinderGeometryType cylinderType = geometry.DstEnds.CylinderGeometryType;
if (cylinderType != null)
{
string tipContextPath = Path.GetDirectoryName(cylinderType.Path);
AddGeometry2Constraint(feapinRep,
cylinderType.Impl as MgaFCO,
tipContextPath, true);
}
}
}
else if (cyphyconstraint.Kind == "BallConstraint")
{
CyPhy.BallConstraint ballConstraint = CyPhyClasses.BallConstraint.Cast(cyphyconstraint.Impl);
foreach (var item in ballConstraint.DstConnections.Ball2SphereCollection)
{
FEABallConstraint feaballRep = new FEABallConstraint();
CyPhy.SphereGeometryType sphereType = item.DstEnds.SphereGeometryType;
if (sphereType != null)
{
string tipContextPath = Path.GetDirectoryName(sphereType.Path);
AddGeometry2Constraint(feaballRep,
sphereType.Impl as MgaFCO,
tipContextPath, true);
}
}
}
else if (cyphyconstraint.Kind == "DisplacementConstraint")
{
CyPhy.DisplacementConstraint displacementConstraint = CyPhyClasses.DisplacementConstraint.Cast(cyphyconstraint.Impl);
string tx = "FREE", ty = "FREE", tz = "FREE", tunit = "mm", rx = "FREE", ry = "FREE", rz = "FREE", runit = "deg";
CyPhy.Rotation rotation = displacementConstraint.Children.RotationCollection.FirstOrDefault();
if (rotation != null)
{
bool hasScalar = (rotation.Attributes.XDirection == CyPhyClasses.Rotation.AttributesClass.XDirection_enum.SCALAR) ||
(rotation.Attributes.YDirection == CyPhyClasses.Rotation.AttributesClass.YDirection_enum.SCALAR) ||
(rotation.Attributes.ZDirection == CyPhyClasses.Rotation.AttributesClass.ZDirection_enum.SCALAR) ;
rx = (rotation.Attributes.XDirection == CyPhyClasses.Rotation.AttributesClass.XDirection_enum.SCALAR) ?
rotation.Attributes.XDirectionValue.ToString() : rotation.Attributes.XDirection.ToString();
ry = (rotation.Attributes.YDirection == CyPhyClasses.Rotation.AttributesClass.YDirection_enum.SCALAR) ?
rotation.Attributes.YDirectionValue.ToString() : rotation.Attributes.YDirection.ToString();
rz = (rotation.Attributes.ZDirection == CyPhyClasses.Rotation.AttributesClass.ZDirection_enum.SCALAR) ?
rotation.Attributes.ZDirectionValue.ToString() : rotation.Attributes.ZDirection.ToString();
if (!hasScalar)
{
runit = "N/A";
}
else
{
if (rotation.Referred.unit != null)
runit = rotation.Referred.unit.Name;
}
}
CyPhy.Translation translation = displacementConstraint.Children.TranslationCollection.FirstOrDefault();
if (translation != null)
{
bool hasScalar = (translation.Attributes.XDirection == CyPhyClasses.Translation.AttributesClass.XDirection_enum.SCALAR) ||
(translation.Attributes.YDirection == CyPhyClasses.Translation.AttributesClass.YDirection_enum.SCALAR) ||
(translation.Attributes.ZDirection == CyPhyClasses.Translation.AttributesClass.ZDirection_enum.SCALAR);
tx = (translation.Attributes.XDirection == CyPhyClasses.Translation.AttributesClass.XDirection_enum.SCALAR) ?
translation.Attributes.XDirectionValue.ToString() : translation.Attributes.XDirection.ToString();
ty = (translation.Attributes.YDirection == CyPhyClasses.Translation.AttributesClass.YDirection_enum.SCALAR) ?
translation.Attributes.YDirectionValue.ToString() : translation.Attributes.YDirection.ToString();
tz = (translation.Attributes.ZDirection == CyPhyClasses.Translation.AttributesClass.ZDirection_enum.SCALAR) ?
translation.Attributes.ZDirectionValue.ToString() : translation.Attributes.ZDirection.ToString();
if (!hasScalar)
{
tunit = "N/A";
}
else
{
if (translation.Referred.unit != null)
tunit = translation.Referred.unit.Name;
}
}
foreach (var item in displacementConstraint.DstConnections.Displacement2GeometryCollection)
{
FEADisplacementConstraint feadispRep = new FEADisplacementConstraint();
feadispRep.Rotation_X = rx;
feadispRep.Rotation_Y = ry;
feadispRep.Rotation_Z = rz;
feadispRep.RotationUnits = runit;
feadispRep.Translation_X = tx;
feadispRep.Translation_Y = ty;
feadispRep.Translation_Z = tz;
feadispRep.TranslationUnits = tunit;
Logger.Instance.AddLogMessage(String.Format("DisplacementConstraint Units - Rotation Component = {0}, Translation Component = {1}", runit, tunit), Severity.Info);
CyPhy.GeometryBase geometry = item.DstEnds.GeometryBase;
if (geometry != null)
{
string tipContextPath = Path.GetDirectoryName(geometry.Path);
AddGeometry2Constraint(feadispRep,
geometry.Impl as MgaFCO,
tipContextPath, true);
}
}
}
}
// Loads
foreach (var cyphyload in testBench.Children.AnalysisLoadCollection)
{
if (cyphyload is CyPhy.ForceLoadParam)
{
CyPhy.ForceLoadParam forceLoad = CyPhyClasses.ForceLoadParam.Cast(cyphyload.Impl);
double fx = 0.0, fy = 0.0, fz = 0.0, mx = 0.0, my = 0.0, mz = 0.0;
string funit = "N", munit = "N-mm";
CyPhy.Parameter p1 = GetForceLoadParam(forceLoad, "ForceX", out fx);
GetForceLoadParam(forceLoad, "ForceY", out fy);
GetForceLoadParam(forceLoad, "ForceZ", out fz);
CyPhy.Parameter p2 = GetForceLoadParam(forceLoad, "MomentX", out mx);
GetForceLoadParam(forceLoad, "MomentY", out my);
GetForceLoadParam(forceLoad, "MomentZ", out mz);
GetParamUnitName(p1, ref funit);
GetParamUnitName(p2, ref munit);
foreach (var item in forceLoad.DstConnections.ForceLoadParam2GeometryCollection)
{
FEAForceLoad feaforceRep = new FEAForceLoad();
feaforceRep.Force_X = fx;
feaforceRep.Force_Y = fy;
feaforceRep.Force_Z = fz;
feaforceRep.ForceUnit = funit;
feaforceRep.Moment_X = mx;
feaforceRep.Moment_Y = my;
feaforceRep.Moment_Z = mz;
feaforceRep.MomentUnit = munit;
Logger.Instance.AddLogMessage(String.Format("ForceLoad Units - Force Component = {0}, Moment Component = {1}", funit, munit), Severity.Info);
CyPhy.GeometryBase geometry = item.DstEnds.GeometryBase;
if (geometry != null)
{
string tipContextPath = Path.GetDirectoryName(geometry.Path);
AddGeometry2Load(feaforceRep,
geometry.Impl as MgaFCO,
tipContextPath, true);
}
}
}
else
if (cyphyload is CyPhy.ForceLoad)
{
Logger.Instance.AddLogMessage("ForceLoad is used in FEA testbench. This construct is obsolete, please use ForceLoadParam instead.", Severity.Warning);
CyPhy.ForceLoad forceLoad = CyPhyClasses.ForceLoad.Cast(cyphyload.Impl);
double fx = 0.0, fy = 0.0, fz = 0.0, mx = 0.0, my = 0.0, mz = 0.0;
string funit = "N", munit = "N-mm";
CyPhy.Force force = forceLoad.Children.ForceCollection.FirstOrDefault();
if (force != null)
{
fx = force.Attributes.XDirectionValue;
fy = force.Attributes.YDirectionValue;
fz = force.Attributes.ZDirectionValue;
if (force.Referred.unit != null)
funit = force.Referred.unit.Name;
}
CyPhy.Moment moment = forceLoad.Children.MomentCollection.FirstOrDefault();
if (moment != null)
{
mx = moment.Attributes.XDirectionValue;
my = moment.Attributes.YDirectionValue;
mz = moment.Attributes.ZDirectionValue;
if (moment.Referred.unit != null)
munit = moment.Referred.unit.Name;
}
foreach (var item in forceLoad.DstConnections.Force2GeometryCollection)
{
FEAForceLoad feaforceRep = new FEAForceLoad();
feaforceRep.Force_X = fx;
feaforceRep.Force_Y = fy;
feaforceRep.Force_Z = fz;
feaforceRep.ForceUnit = funit;
feaforceRep.Moment_X = mx;
feaforceRep.Moment_Y = my;
feaforceRep.Moment_Z = mz;
feaforceRep.MomentUnit = munit;
Logger.Instance.AddLogMessage(String.Format("ForceLoad Units - Force Component = {0}, Moment Component = {1}", funit, munit), Severity.Info);
CyPhy.GeometryBase geometry = item.DstEnds.GeometryBase;
if (geometry != null)
{
string tipContextPath = Path.GetDirectoryName(geometry.Path);
AddGeometry2Load(feaforceRep,
geometry.Impl as MgaFCO,
tipContextPath, true);
}
}
}
else if (cyphyload is CyPhy.AccelerationLoadParam)
{
CyPhy.AccelerationLoadParam acceleration = CyPhyClasses.AccelerationLoadParam.Cast(cyphyload.Impl);
FEAccelerationLoad feaaccelRep = new FEAccelerationLoad();
double x = 0;
double y = 0;
double z = 0;
CyPhy.Parameter p1 = GetAccelerationLoadParam(acceleration, "X", out x);
GetAccelerationLoadParam(acceleration, "Y", out y);
GetAccelerationLoadParam(acceleration, "Z", out z);
feaaccelRep.X = x;
feaaccelRep.Y = y;
feaaccelRep.Z = z;
string unit = "mm/s^2";
GetParamUnitName(p1, ref unit);
feaaccelRep.Units = unit;
Logger.Instance.AddLogMessage(String.Format("AccelerationLoad Units = {0}", feaaccelRep.Units), Severity.Info);
this.Loads.Add(feaaccelRep);
}
else if (cyphyload is CyPhy.AccelerationLoad)
{
Logger.Instance.AddLogMessage("AccelerationLoad is used in FEA testbench. This construct is obsolete, please use AccelerationLoadParam instead.", Severity.Warning);
CyPhy.AccelerationLoad acceleration = CyPhyClasses.AccelerationLoad.Cast(cyphyload.Impl);
FEAccelerationLoad feaaccelRep = new FEAccelerationLoad();
feaaccelRep.X = acceleration.Attributes.XDirectionValue;
feaaccelRep.Y = acceleration.Attributes.YDirectionValue;
feaaccelRep.Z = acceleration.Attributes.ZDirectionValue;
if (acceleration.Referred.unit != null)
feaaccelRep.Units = acceleration.Referred.unit.Name;
else
feaaccelRep.Units = "mm/s^2";
Logger.Instance.AddLogMessage(String.Format("AccelerationLoad Units = {0}", feaaccelRep.Units), Severity.Info);
this.Loads.Add(feaaccelRep);
}
else if (cyphyload is CyPhy.PressureLoadParam)
{
CyPhy.PressureLoadParam pressure = CyPhyClasses.PressureLoadParam.Cast(cyphyload.Impl);
foreach (var item in pressure.DstConnections.PressureParam2GeometryCollection)
{
FEAPressureLoad feapressRep = new FEAPressureLoad();
double p = 0;
CyPhy.Parameter p1 = GetPressureLoadParam(pressure, "PressureLoad", out p);
feapressRep.Value = p;
string unit = "MPa";
GetParamUnitName(p1, ref unit);
feapressRep.Units = unit;
Logger.Instance.AddLogMessage(String.Format("PressureLoad Units = {0}", feapressRep.Units), Severity.Info);
CyPhy.GeometryBase geometry = item.DstEnds.GeometryBase;
if (geometry != null)
{
string tipContextPath = Path.GetDirectoryName(geometry.Path);
AddGeometry2Load(feapressRep,
geometry.Impl as MgaFCO,
tipContextPath, true);
}
}
}
else if (cyphyload is CyPhy.PressureLoad)
{
Logger.Instance.AddLogMessage("PressureLoad is used in FEA testbench. This construct is obsolete, please use PressureLoadParam instead.", Severity.Warning);
CyPhy.PressureLoad pressure = CyPhyClasses.PressureLoad.Cast(cyphyload.Impl);
foreach (var item in pressure.DstConnections.Pressure2GeometryCollection)
{
FEAPressureLoad feapressRep = new FEAPressureLoad();
feapressRep.Value = pressure.Attributes.Value;
if (pressure.Referred.unit != null)
feapressRep.Units = pressure.Referred.unit.Name;
else
feapressRep.Units = "MPa";
Logger.Instance.AddLogMessage(String.Format("PressureLoad Units = {0}", feapressRep.Units), Severity.Info);
CyPhy.GeometryBase geometry = item.DstEnds.GeometryBase;
if (geometry != null)
{
string tipContextPath = Path.GetDirectoryName(geometry.Path);
AddGeometry2Load(feapressRep,
geometry.Impl as MgaFCO,
tipContextPath, true);
}
}
}
}
// Post Processing Blocks
foreach (var postprocess in testBench.Children.PostProcessingCollection)
{
PostProcessScripts.Add(postprocess.Attributes.ScriptPath);
}
}
/***************************************************************************/
/************************* Test Injection Points ***************************/
/***************************************************************************/
public void CreateFlatData(CyPhy.CADTestBench testBench,
string catlsut)
{
List <CyPhy.Component> regular = new List <CyPhy.Component>();
List <CyPhy.Component> size2fit = new List <CyPhy.Component>();
bool asmprocessed = false;
var toplevelSUT = testBench.Children.ComponentAssemblyCollection.FirstOrDefault(); // should be an instance b/c elaborate was called earlier
// CyPhy2CAD_CSharp::ProcessCAD already validated that toplevelSUT != null. Check again in case some removes the check in CyPhy2CAD_CSharp::ProcessCAD
if (toplevelSUT != null)
{
// We must cover the case where the TestBench (TB) only consists of TestInjectionPoints that are
// only Components and not ComponentAssemblies. The following code in this function does not accomodate
// that case. Adding the ReferenceCoordinateSystems now will assure that if a ReferenceCoordinateSystem is set for
// a Component (i.e. part not assembly) that the ReferenceCoordinateSystem will be used and will force that
// component to be added first.
// Also, note that the FindStartingComponent function ignores components with ReferenceCoordinateSystems if those components
// are not actually referenced by the TB. In other words, adding ReferenceCoordinateSystems to
// CyPhy2CAD_CSharp::referenceCoordComponents that are not actually referenced by the TB is not a problem.
ProcessReferenceCoordinateSystems(toplevelSUT);
}
foreach (var tip in testBench.Children.TestInjectionPointCollection)
{
if (tip.Referred != null)
{
string tipKind = tip.Referred.TIPRefBase.Kind;
Logger.Instance.AddLogMessage("Test Injection Point kind is: [" + tipKind + "]", Severity.Info);
if (tipKind == "Component")
{
CyPhy.Component component = tip.Referred.Component;
if (CheckComponent(component))
{
// size2fit or regular
if (component.Children.SizedToFitCollection.Any())
{
size2fit.Add(component);
}
else
{
regular.Add(component);
}
}
}
else if (tipKind == "ComponentAssembly")
{
List <CyPhy.Component> asmregular = new List <CyPhy.Component>();
List <CyPhy.Component> asmsize2fitcomponents = new List <CyPhy.Component>();
CyPhy.ComponentAssembly componentAsm = tip.Referred.ComponentAssembly;
FindComponents(componentAsm,
asmregular,
asmsize2fitcomponents);
ProcessComponents(asmregular, asmsize2fitcomponents, componentAsm);
ProcessReferenceCoordinateSystems(componentAsm);
asmprocessed = true;
}
else
{
Logger.Instance.AddLogMessage("Not supported Test Injection Point kind [" + tipKind + "]", Severity.Error);
}
}
else
{
throw new META.InterpreterException("Null Test Injection Point in FEA Test Bench!");
}
}
/*
* if (regular.Count < 1)
* {
* }
*
* // [] Create CADComponent, size2fit, and edges
* foreach (var item in regular)
* {
* DataRep.CADComponent component = new DataRep.CADComponent(item, ProjectDirectory: this.ProjectDirectory);
* this.regularComponents[item.ID] = component;
*
* }
*
* foreach (var item in size2fit)
* {
* DataRep.CADComponent component = new DataRep.CADComponent(item, ProjectDirectory: this.ProjectDirectory, size2fit: true);
* this.size2fitComponents[item.ID] = component;
* }
*
* // [] Create Edges
* foreach (KeyValuePair<string, DataRep.CADComponent> item in size2fitComponents)
* {
* CreateEdges(item.Value, null, true); // snyako: what's the top assembly here?
* }
*
* foreach (KeyValuePair<string, DataRep.CADComponent> item in regularComponents)
* {
* CreateEdges(item.Value, null); // snyako: what's the top assembly here?
* }
*
* // [] Print Assembly
* PrintAssembly();*/
if (!asmprocessed || (regular.Count != 0 && size2fit.Count != 0))
{
ProcessComponents(regular, size2fit, null);
}
}
private void ProcessCAD(MgaFCO currentobj)
{
string outputdir = this.mainParameters.OutputDirectory;
if (!Directory.Exists(outputdir))
{
Directory.CreateDirectory(outputdir);
}
string debuglogdir = Path.Combine(outputdir, "log");
if (!Directory.Exists(debuglogdir))
{
Directory.CreateDirectory(debuglogdir);
}
string projectdir = this.mainParameters.ProjectDirectory;
CyPhy2CADSettings cadSetting = (CyPhy2CADSettings)this.mainParameters.config;
string cadauxdir = cadSetting.AuxiliaryDirectory;
CyPhy.ComponentAssembly curassembly;
string curObjMetaBase = currentobj.MetaBase.Name;
if (curObjMetaBase == "TestBench" || curObjMetaBase == "BallisticTestBench" || curObjMetaBase == "CFDTestBench" || curObjMetaBase == "BlastTestBench" || curObjMetaBase == "KinematicTestBench")
{
CyPhy.TestBenchType tb = CyPhyClasses.TestBenchType.Cast(currentobj);
if (result != null && curObjMetaBase == "BlastTestBench")
{
result.Labels = JobManager.Job.DefaultLabels + "&&SwRI_Blast";
}
if (result != null && curObjMetaBase == "KinematicTestBench")
{
result.Labels = JobManager.Job.DefaultLabels + "&&Adams";
}
var catlsut = tb.Children.ComponentAssemblyCollection.FirstOrDefault(); // should be an instance b/c elaborate was called earlier
if (catlsut == null)
{
result.Success = false;
throw new Exception("There is no elaborated system under test component assembly in the model!");
}
curassembly = catlsut;
if (curassembly == null)
{
result.Success = false;
throw new Exception("No Valid Component Assembly.");
}
// META-1971: ADM + ACM file export for blast + ballistics
if (curObjMetaBase == "BallisticTestBench" || curObjMetaBase == "BlastTestBench")
{
// ADM: Export DDP 2.x version (XML)
{
var design = CyPhy2DesignInterchange.CyPhy2DesignInterchange.Convert(catlsut, this.result.Traceability);
string TestBenchName = tb.Name;
string admDir = Path.Combine(cadSetting.OutputDirectory, "DesignADM");
if (!Directory.Exists(admDir))
{
Directory.CreateDirectory(admDir);
}
OpenMETA.Interchange.AvmXmlSerializer.SaveToFile(Path.Combine(admDir, TestBenchName + ".adm"), design);
}
}
// end META-1971
// META-2987
GenerateCADParameterMapping(tb,
outputdir, new List <object>());
CADFlatDataCreator datacreator = new CADFlatDataCreator(debuglogdir, this.mainParameters.ProjectDirectory, CadFormat);
datacreator.Traceability = this.result.Traceability;
datacreator.CreateFlatData(curassembly);
DataRep.CADContainer cadcontainer = datacreator.CreateCADDataContainer(curassembly.Attributes.ConfigurationUniqueID,
UtilityHelpers.CleanString2(curassembly.Name));
using (StreamWriter writer = new StreamWriter(Path.Combine(outputdir, "log", "CyPhy2CAD_Graphviz_Representation.gv")))
{
writer.WriteLine(cadcontainer.ToGraphviz(true));
}
if (!cadcontainer.IsAnalyzable() && curObjMetaBase != "TestBench")
{
result.Success = false;
//Logger.Instance.AddLogMessage("Test Bench can not proceed because the test bench contains islands and/or orphans! Please see graphviz file in /log directory for details.", Severity.Error);
throw new META.InterpreterException("Test Bench can not proceed because the test bench contains islands and/or orphans, see graphviz file in /log/CyPhy2CAD_Graphviz_Representation.gv for details. Please remove islands/orphans and try again.");
}
TestBenchModel.TestBenchBase testBenchRep = TestBenchModelFactory.CreateTestBenchModel(curObjMetaBase,
cadSetting,
outputdir,
projectdir,
Automation);
testBenchRep.cadDataContainer = cadcontainer;
testBenchRep.CopySTL = this.CopySTL;
if (curObjMetaBase != "ComponentAssembly")
{
testBenchRep.TraverseTestBench(tb);
}
testBenchRep.CollectDirectories();
result.Success = testBenchRep.GenerateOutputFiles();
}
else if (curObjMetaBase == "CADTestBench")
{
CyPhy.CADTestBench tb = CyPhyClasses.CADTestBench.Cast(currentobj);
// META-1701: label for Abaqus
if (result != null)
{
Dictionary <CyPhyClasses.CADTestBench.AttributesClass.SolverType_enum, string> labelMap = new Dictionary <CyPhyClasses.CADTestBench.AttributesClass.SolverType_enum, string>()
{
{ CyPhyClasses.CADTestBench.AttributesClass.SolverType_enum.ABAQUS_Deck_Based, "Abaqus" },
{ CyPhyClasses.CADTestBench.AttributesClass.SolverType_enum.ABAQUS_Model_Based, "Abaqus" },
{ CyPhyClasses.CADTestBench.AttributesClass.SolverType_enum.NASTRAN, "Nastran" },
};
string label = "Abaqus";
labelMap.TryGetValue(tb.Attributes.SolverType, out label);
result.Labels += "&&" + label;
}
var toplevelSUT = tb.Children.ComponentAssemblyCollection.FirstOrDefault(); // should be an instance b/c elaborate was called earlier
if (toplevelSUT == null)
{
result.Success = false;
throw new Exception("There is no elaborated system under test component assembly in the model!");
}
CADFlatDataCreator datacreator = new CADFlatDataCreator(debuglogdir, this.mainParameters.ProjectDirectory, CadFormat);
datacreator.Traceability = this.result.Traceability;
datacreator.CreateFlatData(tb,
toplevelSUT.Path);
DataRep.CADContainer cadcontainer = datacreator.CreateCADDataContainer(tb.Guid.ToString(),
UtilityHelpers.CleanString2(tb.Name));
using (StreamWriter writer = new StreamWriter(Path.Combine(outputdir, "log", "CyPhy2CAD_Graphviz_Representation.gv")))
{
writer.WriteLine(cadcontainer.ToGraphviz(true));
}
result.Success = false;
if (!cadcontainer.IsAnalyzable())
{
//Logger.Instance.AddLogMessage("FEA Test Bench can not proceed because the test bench contains islands and/or orphans! Please see graphviz file in /log directory for details.", Severity.Error);
throw new META.InterpreterException("FEA Test Bench can not proceed because the test bench contains islands and/or orphans, see graphviz file in /log/CyPhy2CAD_Graphviz_Representation.gv for details. Please remove islands/orphans and try again.");
}
TestBenchModel.TestBenchBase testBenchRep = TestBenchModelFactory.CreateTestBenchModel(curObjMetaBase,
cadSetting,
outputdir,
projectdir,
Automation);
testBenchRep.cadDataContainer = cadcontainer;
testBenchRep.CopySTL = this.CopySTL;
testBenchRep.TraverseTestBench(tb);
testBenchRep.CollectDirectories();
result.Success = testBenchRep.GenerateOutputFiles();
List <object> mappings = new List <object>();
if (testBenchRep is TestBenchModel.FEATestBench)
{
var feaRep = (TestBenchModel.FEATestBench)testBenchRep;
mappings = feaRep.TestBenchParameterMappings;
}
// META-2987
GenerateCADParameterMapping(tb, outputdir, mappings);
}
else if (curObjMetaBase == "ComponentAssembly")
{
curassembly = CyPhyClasses.ComponentAssembly.Cast(currentobj);
CADFlatDataCreator datacreator = new CADFlatDataCreator(debuglogdir, this.mainParameters.ProjectDirectory, CadFormat);
datacreator.Traceability = this.result.Traceability;
datacreator.CreateFlatData(curassembly);
DataRep.CADContainer cadcontainer = datacreator.CreateCADDataContainer(curassembly.Guid.ToString(),
UtilityHelpers.CleanString2(curassembly.Name));
TestBenchModel.TestBenchBase testbenchbase = new TestBenchModel.TestBenchBase(cadSetting,
outputdir,
projectdir);
testbenchbase.cadDataContainer = cadcontainer;
testbenchbase.CopySTL = this.CopySTL;
testbenchbase.CollectDirectories();
}
else
{
result.Success = false;
throw new NotImplementedException(String.Format("Running Cyphy2CAD on {0} is not implemented.", curObjMetaBase));
}
}