// Exports the whole configuration as one fused part to an IGES file void CTiglExportIges::ExportFusedIGES(const std::string& filename) { if (filename.empty()) { LOG(ERROR) << "Error: Empty filename in ExportFusedIGES."; return; } PTiglFusePlane fuser = _config.AircraftFusingAlgo(); fuser->SetResultMode(HALF_PLANE_TRIMMED_FF); assert(fuser); PNamedShape fusedAirplane = fuser->FusedPlane(); PNamedShape farField = fuser->FarField(); if (!fusedAirplane) { throw CTiglError("Error computing fused airplane.", TIGL_NULL_POINTER); } try { ListPNamedShape l; l.push_back(fusedAirplane); l.push_back(farField); // add intersections const ListPNamedShape& ints = fuser->Intersections(); ListPNamedShape::const_iterator it; for (it = ints.begin(); it != ints.end(); ++it) { l.push_back(*it); } ExportShapes(l, filename); } catch (CTiglError&) { throw CTiglError("Cannot export fused Airplane as IGES", TIGL_ERROR); } }
void CCPACSWingRibExplicitPositioning::ReadCPACS(TixiDocumentHandle tixiHandle, const std::string& explicitRibPosXPath) { Cleanup(); // Get subelement "startReference" char* ptrStartReference = NULL; if (tixiGetTextElement(tixiHandle, (explicitRibPosXPath + "/startReference").c_str(), &ptrStartReference) != SUCCESS) { LOG(ERROR) << "Missing startReference"; throw CTiglError("Error: Missing startReference in CCPACSWingRibExplicitPositioning::ReadCPACS!", TIGL_XML_ERROR); } startReference = ptrStartReference; // Get subelement "etaStart" ReturnCode tixiRet = tixiGetDoubleElement(tixiHandle, (explicitRibPosXPath + "/etaStart").c_str(), &startEta); if (tixiRet != SUCCESS) { LOG(ERROR) << "Missing etaStart"; throw CTiglError("Error: Missing etaStart in CCPACSWingRibExplicitPositioning::ReadCPACS!", TIGL_XML_ERROR); } // Get subelement "endReference" char* ptrEndReference = NULL; if (tixiGetTextElement(tixiHandle, (explicitRibPosXPath + "/endReference").c_str(), &ptrEndReference) != SUCCESS) { LOG(ERROR) << "Missing endReference"; throw CTiglError("Error: Missing endReference in CCPACSWingRibExplicitPositioning::ReadCPACS!", TIGL_XML_ERROR); } endReference = ptrEndReference; // Get subelement "etaEnd" tixiRet = tixiGetDoubleElement(tixiHandle, (explicitRibPosXPath + "/etaEnd").c_str(), &endEta); if (tixiRet != SUCCESS) { LOG(ERROR) << "Missing etaEnd"; throw CTiglError("Error: Missing etaEnd in CCPACSWingRibExplicitPositioning::ReadCPACS!", TIGL_XML_ERROR); } }
void CCPACSWingCellPositionChordwise::ReadCPACS(TixiDocumentHandle tixiHandle, const std::string& xpath) { Reset(); // Get subelement "xsi1, xsi2" or Spar Uid (choice) const std::string sparUIdString = xpath + "/sparUID"; const std::string xsi1String = xpath + "/xsi1"; if (tixiCheckElement(tixiHandle, xsi1String.c_str()) == SUCCESS) { m_inputType = Xsi; if (tixiGetDoubleElement(tixiHandle, xsi1String.c_str(), &m_xsi1) != SUCCESS) { LOG(ERROR) << "Error during read of <xsi1>"; throw CTiglError("Error: Error during read of <xsi1> in CCPACSWingCellPositionChordwise::ReadCPACS!", TIGL_XML_ERROR); } if (tixiGetDoubleElement(tixiHandle, (xpath + "/xsi2").c_str(), &m_xsi2) != SUCCESS) { LOG(ERROR) << "Error during read of <xsi2>"; throw CTiglError("Error: Error during read of <xsi2> in CCPACSWingCellPositionChordwise::ReadCPACS!", TIGL_XML_ERROR); } } else if (tixiCheckElement(tixiHandle, sparUIdString.c_str()) == SUCCESS) { m_inputType = Spar; char* ptrSUId = NULL; if (tixiGetTextElement(tixiHandle, sparUIdString.c_str(), &ptrSUId) != SUCCESS) { LOG(ERROR) << "Error during read of <sparUID>"; throw CTiglError("Error: Error during read of <sparUID> in CCPACSWingCellPositionChordwise::ReadCPACS!", TIGL_XML_ERROR); } m_sparUID = ptrSUId; } else { LOG(ERROR) << "Missing element <xsi1> or <sparUID>"; throw CTiglError("Error: Missing element <xsi1> or <sparUID> in CCPACSWingCellPositionChordwise::ReadCPACS!", TIGL_XML_ERROR); } }
// Returns a pointer to the geometric component for the given unique id. CTiglAbstractPhysicalComponent* CTiglUIDManager::GetPhysicalComponent(const std::string& uid) { if (uid.empty()) { throw CTiglError("Empty UID in CTiglUIDManager::GetComponent", TIGL_XML_ERROR); } if (physicalShapes.find(uid) == physicalShapes.end()) { throw CTiglError("UID not found in CTiglUIDManager::GetComponent", TIGL_XML_ERROR); } return physicalShapes[uid]; }
CCPACSFuselageProfileGetPointAlgo::CCPACSFuselageProfileGetPointAlgo (const TopTools_SequenceOfShape& wireContainer) { try { if (wireContainer.Length()!=1) { throw CTiglError("Error: CCPACSWingProfileGetPointAlgo: Number of wires is not equal 1", TIGL_ERROR); } wire = TopoDS::Wire(wireContainer(1)); } catch(...) { throw CTiglError("Error: CCPACSFuselageProfileGetPointAlgo: Conversion of shape to wire failed", TIGL_ERROR); } wireLength = GetWireLength(wire); }
// Returns a pointer to the geometric component for the given unique id. ITiglGeometricComponent* CTiglUIDManager::GetComponent(const std::string& uid) { if (uid.empty()) { throw CTiglError("Empty UID in CTiglUIDManager::GetComponent", TIGL_UID_ERROR); } if (!HasUID(uid)) { std::stringstream stream; stream << "UID " << uid << " not found in CTiglUIDManager::GetComponent"; throw CTiglError(stream.str(), TIGL_UID_ERROR); } return allShapes[uid]; }
// Read CPACS fuselage section elements void CCPACSFuselageSectionElements::ReadCPACS(TixiDocumentHandle tixiHandle, const std::string& sectionXPath) { Cleanup(); ReturnCode tixiRet; int elementCount; std::string tempString; char* elementPath; /* Get section element count */ tempString = sectionXPath + "/elements"; elementPath = const_cast<char*>(tempString.c_str()); tixiRet = tixiGetNamedChildrenCount(tixiHandle, elementPath, "element", &elementCount); if (tixiRet != SUCCESS) { throw CTiglError("XML error: tixiGetNamedChildrenCount failed in CCPACSFuselageSectionElements::ReadCPACS", TIGL_XML_ERROR); } // Loop over all section elements for (int i = 1; i <= elementCount; i++) { CCPACSFuselageSectionElement* element = new CCPACSFuselageSectionElement(); elements.push_back(element); tempString = sectionXPath + "/elements/element["; std::ostringstream xpath; xpath << tempString << i << "]"; element->ReadCPACS(tixiHandle, xpath.str()); } }
// Read CPACS section elements void CCPACSFuselageConnection::ReadCPACS(TixiDocumentHandle tixiHandle, const std::string& connectionXPath) { Cleanup(); char* elementPath; std::string tempString; // Get subelement "element" char* ptrElementUID = NULL; tempString = connectionXPath; elementPath = const_cast<char*>(tempString.c_str()); if (tixiGetTextElement(tixiHandle, elementPath, &ptrElementUID) != SUCCESS) { throw CTiglError("Error: Can't read element <element/> in CCPACSFuselageConnection::ReadCPACS", TIGL_XML_ERROR); } elementUID = ptrElementUID; // find the corresponding section to this segment CCPACSFuselage& fuselage = segment->GetFuselage(); for (int i=1; i <= fuselage.GetSectionCount(); i++) { CCPACSFuselageSection& section = fuselage.GetSection(i); for (int j=1; j <= section.GetSectionElementCount(); j++) { if (section.GetSectionElement(j).GetUID() == elementUID ) { sectionUID = section.GetUID(); sectionIndex = i; elementIndex = j; } } } }
std::pair<double, double> CCPACSWingCellPositionChordwise::GetXsi() const { if (m_inputType != Xsi) { throw CTiglError("CCPACSWingCellPositionChordwise::GetXsi method called, but position is defined via sparUID!"); } return std::make_pair(m_xsi1, m_xsi2); }
const std::string& CCPACSWingCellPositionChordwise::GetSparUId() const { if (m_inputType != Spar) { throw CTiglError("CCPACSWingCellPositionChordwise::GetSparUId method called, but position is defined via xsi1/xsi2!"); } return m_sparUID; }
void CCPACSControlSurfaceDeviceAirfoil::ReadCPACS(TixiDocumentHandle tixiHandle, const std::string& xpath) { char* tmp = NULL; if (tixiGetTextElement(tixiHandle, (xpath + "/airfoilUID").c_str(), &tmp) == SUCCESS) { _airfoilUID = tmp; // check if airfoil exists by query _config->GetWingProfile(_airfoilUID); } else { throw CTiglError("Missing airfoilUID element in path: " + xpath + "!", TIGL_OPEN_FAILED); } _rotX = 90.0; if (tixiCheckElement(tixiHandle, (xpath + "/rotX").c_str()) == SUCCESS) { tixiGetDoubleElement(tixiHandle, (xpath + "/rotX").c_str(), &_rotX); } // check, if yscale != 1. If yes, we show a warning double scalY; if (tixiCheckElement(tixiHandle, (xpath + "/scalY").c_str()) == SUCCESS) { tixiGetDoubleElement(tixiHandle, (xpath + "/scalY").c_str(), &scalY); if (fabs(scalY - 1.0) > 1e-10) { LOG(WARNING) << "Y scaling in \"" << xpath << "\" ignored. Only 2D profiles supported."; } } _scalZ = 1.0; if (tixiCheckElement(tixiHandle, (xpath + "/scalZ").c_str()) == SUCCESS) { tixiGetDoubleElement(tixiHandle, (xpath + "/scalZ").c_str(), &_scalZ); } }
// Read CPACS positionings element void CCPACSWingPositionings::ReadCPACS(TixiDocumentHandle tixiHandle, const std::string& wingXPath) { Cleanup(); ReturnCode tixiRet; int positioningCount; std::string tempString; char* elementPath; /* Get positioning element count */ tempString = wingXPath + "/positionings"; elementPath = const_cast<char*>(tempString.c_str()); tixiRet = tixiGetNamedChildrenCount(tixiHandle, elementPath, "positioning", &positioningCount); if (tixiRet != SUCCESS) { throw CTiglError("XML error: tixiGetNamedChildrenCount failed in CCPACSWingPositionings::ReadCPACS", TIGL_XML_ERROR); } // Loop over all positionings for (int i = 1; i <= positioningCount; i++) { CCPACSWingPositioning* positioning = new CCPACSWingPositioning(); tempString = wingXPath + "/positionings/positioning["; std::ostringstream xpath; xpath << tempString << i << "]"; positioning->ReadCPACS(tixiHandle, xpath.str()); positionings[positioning->GetOuterSectionIndex()] = positioning; } Update(); }
gp_Pnt getSectionElementChordlinePoint(const CCPACSWingComponentSegment& cs, const std::string& sectionElementUID, double xsi) { gp_Pnt chordlinePoint; CCPACSWing& wing = cs.GetWing(); // find section element const CCPACSWingSegment& segment = static_cast<const CCPACSWingSegment&>(wing.GetSegment(1)); if (sectionElementUID == segment.GetInnerSectionElementUID()) { // convert into wing coordinate system CTiglTransformation wingTrans = wing.GetTransformation(); chordlinePoint = wingTrans.Inverted().Transform(segment.GetChordPoint(0, xsi)); } else { int i; for (i = 1; i <= wing.GetSegmentCount(); ++i) { const CCPACSWingSegment& segment = static_cast<const CCPACSWingSegment&>(wing.GetSegment(i)); if (sectionElementUID == segment.GetOuterSectionElementUID()) { // convert into wing coordinate system CTiglTransformation wingTrans = wing.GetTransformation(); chordlinePoint = wingTrans.Inverted().Transform(segment.GetChordPoint(1, xsi)); break; } } if (i > wing.GetSegmentCount()) { throw CTiglError("Error in getSectionElementChordlinePoint: section element not found!"); } } return chordlinePoint; }
double computeRibEtaValue(const CTiglWingStructureReference& wsr, const CCPACSWingRibsDefinition& rib, int ribIndex, double xsi) { // determine rib start and ent point gp_Pnt ribStartPoint, ribEndPoint; rib.GetRibMidplanePoints(ribIndex, ribStartPoint, ribEndPoint); double startEta, startXsi, endEta, endXsi; wsr.GetMidplaneEtaXsi(ribStartPoint, startEta, startXsi); wsr.GetMidplaneEtaXsi(ribEndPoint, endEta, endXsi); // fix numeric inaccuracy in xsi double precision = 1.E-8; if (xsi < startXsi && xsi >= (startXsi - precision)) { xsi = startXsi; } else if (xsi > endXsi && xsi <= (endXsi + precision)) { xsi = endXsi; } if (xsi < startXsi || xsi > endXsi) { throw CTiglError("Error in computeRibEtaValue: rib is not defined at passed xsi coordinate!"); } // NOTE: may not be fully correct when rib lies within more than 1 segment! return startEta + (endEta - startEta) * ((xsi - startXsi) / (endXsi - startXsi)); }
// Read CPACS wing sections element void CCPACSWingSections::ReadCPACS(TixiDocumentHandle tixiHandle, const std::string& wingXPath) { Cleanup(); ReturnCode tixiRet; int sectionCount; std::string tempString; char* elementPath; /* Get section element count */ tempString = wingXPath + "/sections"; elementPath = const_cast<char*>(tempString.c_str()); tixiRet = tixiGetNamedChildrenCount(tixiHandle, elementPath, "section", §ionCount); if (tixiRet != SUCCESS) { throw CTiglError("XML error: tixiGetNamedChildrenCount failed in CCPACSWingSections::ReadCPACS", TIGL_XML_ERROR); } // Loop over all sections for (int i = 1; i <= sectionCount; i++) { CCPACSWingSection* section = new CCPACSWingSection(); sections.push_back(section); tempString = wingXPath + "/sections/section["; std::ostringstream xpath; xpath << tempString << i << "]"; section->ReadCPACS(tixiHandle, xpath.str()); } }
// Returns the wing for a given index. CCPACSWing& CCPACSWings::GetWing(int index) const { index --; if (index < 0 || index >= GetWingCount()) { throw CTiglError("Error: Invalid index in CCPACSWings::GetWing", TIGL_INDEX_ERROR); } return (*wings[index]); }
bool CCPACSWingProfile::HasBluntTE() const { PTiglWingProfileAlgo algo = GetProfileAlgo(); if (!algo) { throw CTiglError("No wing profile algorithm regsitered in CCPACSWingProfile::HasBluntTE()!"); } return algo->HasBluntTE(); }
// Returns the section for a given index CCPACSWingSection& CCPACSWingSections::GetSection(int index) const { index--; if (index < 0 || index >= GetSectionCount()) { throw CTiglError("Error: Invalid index in CCPACSWingSections::GetSection", TIGL_INDEX_ERROR); } return (*sections[index]); }
// Get element for a given index CCPACSFuselageSectionElement& CCPACSFuselageSectionElements::GetSectionElement(int index) const { index--; if (index < 0 || index >= GetSectionElementCount()) { throw CTiglError("Error: Invalid index in CCPACSFuselageSectionElements::GetSectionElement", TIGL_INDEX_ERROR); } return (*elements[index]); }
// Checks if a UID already exists. bool CTiglUIDManager::HasUID(const std::string& uid) const { if (uid.empty()) { throw CTiglError("Empty UID in CTiglUIDManager::HasUID", TIGL_XML_ERROR); } return (allShapes.find(uid) != allShapes.end()); }
// Sets a value of the transformation matrix by row/col void CTiglTransformation::SetValue(int row, int col, double value) { if (row < 0 || row > 3 || col < 0 || col > 3) { throw CTiglError("Error: Invalid row or column index in CTiglTransformation::SetValue", TIGL_INDEX_ERROR); } m_matrix[row][col] = value; }
CTiglFileLogger::CTiglFileLogger(FILE * file) : logFileStream(file), mutex(new CMutex), verbosity(TILOG_DEBUG4) { if (!logFileStream) { throw CTiglError("Null pointer for argument file in CTiglLogFile", TIGL_NULL_POINTER); } fileOpened = false; }
// Returns the rotor hinge for a given index. CCPACSRotorHinge& CCPACSRotorHinges::GetRotorHinge(int index) const { index--; if (index < 0 || index >= GetRotorHingeCount()) { throw CTiglError("Error: Invalid index in CCPACSRotorHinges::GetRotorHinge", TIGL_INDEX_ERROR); } return (*rotorHinges[index]); }
CCPACSWingSparSegment& CCPACSWingSparSegments::GetSparSegment(int index) const { const int idx = index - 1; if (idx < 0 || idx >= GetSparSegmentCount()) { LOG(ERROR) << "Invalid index value"; throw CTiglError("Error: Invalid index value in CCPACSWingSparSegments::getSparSegment", TIGL_INDEX_ERROR); } return (*(sparSegments[idx])); }
// Returns the wing profile for a given uid. CCPACSWingProfile& CCPACSWingProfiles::GetProfile(std::string uid) const { CCPACSWingProfileContainer::const_iterator it = profiles.find(uid); if (it != profiles.end() && it->second) { return *(it->second); } else { throw CTiglError("Wing profile \"" + uid + "\" not found in CPACS file!", TIGL_UID_ERROR); } }
void CTiglControlSurfaceHingeLine::buildHingeLine() const { if (!_invalidated) { return; } if (!_segment || !_path || !_outerShape) { throw CTiglError("Null pointer in CTiglControlSurfaceHingeLine::buildHingeLine!", TIGL_NULL_POINTER); } // Calculate inner and outer HingePoint for ( int borderCounter = 0; borderCounter < 2; borderCounter++ ) { const CCPACSControlSurfaceDeviceOuterShapeBorder* border = NULL; double hingeXsi; if (borderCounter == 0) { border = &_outerShape->getOuterBorder(); hingeXsi = _path->getOuterHingePoint().getXsi(); } else { border = &_outerShape->getInnerBorder(); hingeXsi = _path->getInnerHingePoint().getXsi(); } double borderEtaLE = border->getEtaLE(); double borderEtaTE = border->getEtaTE(); double hingeEta = -1; // only calculate etaCoordinate if it´s not the same as the other one. if ( fabs(borderEtaLE - borderEtaTE) < 0.0001 ) { hingeEta = (borderEtaTE + borderEtaLE)/2; } else { double m = ( borderEtaLE - borderEtaTE )/(border->getXsiLE() - border->getXsiTE()); hingeEta = m * (hingeXsi - border->getXsiLE()) + borderEtaLE; } double eta = 0.,xsi = 0.; CCPACSWingSegment* wsegment = _segment->GetSegmentEtaXsi(hingeEta,hingeXsi,eta,xsi); gp_Pnt hingeUpper = wsegment->GetUpperPoint(eta,xsi); gp_Pnt hingeLower = wsegment->GetLowerPoint(eta,xsi); if (borderCounter == 0) { double relHeight = _path->getOuterHingePoint().getRelHeight(); gp_Vec upperToLower = (gp_Vec(hingeLower.XYZ()) - gp_Vec(hingeUpper.XYZ())).Multiplied(relHeight); _outerHingePoint = gp_Pnt(( gp_Vec(hingeUpper.XYZ()) + gp_Vec(upperToLower.XYZ() )).XYZ()); } else { double relHeight = _path->getInnerHingePoint().getRelHeight(); gp_Vec upperToLower = (gp_Vec(hingeLower.XYZ()) - gp_Vec(hingeUpper.XYZ())).Multiplied(relHeight); _innerHingePoint = gp_Pnt(( gp_Vec(hingeUpper.XYZ()) + gp_Vec(upperToLower.XYZ() )).XYZ()); } } _invalidated = false; }
/** * @briefAdds a shape to the IGES file. All faces are named according to their face * traits. If there are no faces, the wires are named according to the shape name. * * The level parameter defines the iges layer/level, which is another way of grouping faces. */ void CTiglExportIges::AddToIges(PNamedShape shape, IGESControl_Writer& writer, int level) const { if (!shape) { return; } std::string shapeName = shape->Name(); std::string shapeShortName = shape->ShortName(); Handle(Transfer_FinderProcess) FP = writer.TransferProcess(); TopTools_IndexedMapOfShape faceMap; TopExp::MapShapes(shape->Shape(), TopAbs_FACE, faceMap); // any faces? if (faceMap.Extent() > 0) { int ret = writer.AddShape(shape->Shape()); if (ret > IFSelect_RetDone) { throw CTiglError("Error: Export to IGES file failed in CTiglExportStep. Could not translate shape " + shapeName + " to iges entity,", TIGL_ERROR); } WriteIgesNames(FP, shape, level); } else { // no faces, export edges as wires Handle(TopTools_HSequenceOfShape) Edges = new TopTools_HSequenceOfShape(); TopExp_Explorer myEdgeExplorer (shape->Shape(), TopAbs_EDGE); while (myEdgeExplorer.More()) { Edges->Append(TopoDS::Edge(myEdgeExplorer.Current())); myEdgeExplorer.Next(); } ShapeAnalysis_FreeBounds::ConnectEdgesToWires(Edges, 1e-7, false, Edges); for (int iwire = 1; iwire <= Edges->Length(); ++iwire) { int ret = writer.AddShape(Edges->Value(iwire)); if (ret > IFSelect_RetDone) { throw CTiglError("Error: Export to IGES file failed in CTiglExportIges. Could not translate shape " + shapeName + " to iges entity,", TIGL_ERROR); } PNamedShape theWire(new CNamedShape(Edges->Value(iwire),shapeName.c_str())); theWire->SetShortName(shapeShortName.c_str()); WriteIGESShapeNames(FP, theWire, level); WriteIgesWireName(FP, theWire); } } }
// Returns the guide curve for a given uid. CCPACSGuideCurveProfile& CCPACSGuideCurveProfiles::GetGuideCurveProfile(std::string uid) const { CCPACSGuideCurveProfileContainer::const_iterator it = guideCurves.find(uid); if (it != guideCurves.end() && it->second) { return *(it->second); } else { LOG(ERROR) << "Guide curve \"" + uid + "\" not found in CPACS file!" << endl; throw CTiglError("Guide curve \"" + uid + "\" not found in CPACS file!", TIGL_UID_ERROR); } }
// Function to add a UID and a geometric component to the uid store. void CTiglUIDManager::AddUID(const std::string& uid, ITiglGeometricComponent* componentPtr) { if (uid.empty()) { throw CTiglError("Empty UID in CTiglUIDManager::AddUID", TIGL_XML_ERROR); } if (HasUID(uid)) { throw CTiglError("Duplicate UID " + uid + " in CPACS file (CTiglUIDManager::AddUID)", TIGL_XML_ERROR); } if (componentPtr == 0) { throw CTiglError("Null pointer for component in CTiglUIDManager::AddUID", TIGL_NULL_POINTER); } CTiglAbstractPhysicalComponent* tmp = dynamic_cast<CTiglAbstractPhysicalComponent*>(componentPtr); if (tmp && (componentPtr->GetComponentType() | TIGL_COMPONENT_PHYSICAL) ) { physicalShapes[uid] = tmp; } allShapes[uid] = componentPtr; invalidated = true; }
double computeSparXsiValue(const CTiglWingStructureReference& wsr, const CCPACSWingSparSegment& spar, double eta) { TopoDS_Wire sparMidplaneLine = spar.GetSparMidplaneLine(); TopoDS_Face etaCutFace = buildEtaCutFace(wsr, eta); gp_Pnt etaXsiPoint; if (!GetIntersectionPoint(etaCutFace, sparMidplaneLine, etaXsiPoint)) { throw CTiglError("Error in computation of spar eta point in tigletaxsifunctions::computeSparXsiValue"); } double newEta, xsi; wsr.GetMidplaneEtaXsi(etaXsiPoint, newEta, xsi); return xsi; }