Atomizer/docs/05_API_REFERENCE/NXOPEN_RESOURCES.md

NXOpen Resources and References

Overview

This document lists valuable resources for NXOpen development that can inform our implementation without direct code copying.

---

Primary Resources

1. Official Siemens NXOpen API Documentation

URL: https://docs.sw.siemens.com/en-US/doc/209349590/PL20231101866122454.custom_api.nxopen_net

Usage:

• Primary reference for API syntax and methods
• Official namespace documentation
• Method signatures and return types
• Parameter descriptions

Integration Strategy:

• MCP tool search_nxopen_docs will fetch pages on-demand
• Cache frequently-used API snippets locally
• LLM can reference documentation when generating NXOpen code

---

2. NXOpenTSE by The Scripting Engineer

GitHub: https://github.com/theScriptingEngineer/nxopentse/tree/main Documentation: https://nxopentsedocumentation.thescriptingengineer.com/

About NXOpenTSE

NXOpenTSE is an open-source Python library that provides:

• High-level wrappers around NXOpen API
• Utility functions for common NX operations
• Well-documented examples of NX automation patterns
• Best practices for NX scripting

License: MIT (as of last check - verify before use)

Why NXOpenTSE is Valuable for Atomizer

1. Reference for Design Patterns:

   • How to structure NXOpen scripts
   • Error handling approaches
   • Session management patterns
   • Part loading/unloading workflows

2. Understanding API Usage:

   • See real-world examples of API calls
   • Learn parameter combinations that work
   • Understand method call sequences

3. Avoiding Common Pitfalls:

   • See solutions to typical problems
   • Learn about NX-specific gotchas
   • Understand threading/transaction requirements

4. Inspiration for Features:

   • Discover what's possible with NXOpen
   • See advanced techniques
   • Learn about lesser-known APIs

Integration Strategy for Atomizer

Approach: Reference, don't copy

✅ DO:
- Study NXOpenTSE documentation for understanding NX concepts
- Reference example patterns when writing our own code
- Learn from error handling approaches
- Use as inspiration for our API wrapper design
- Link to NXOpenTSE docs in our MCP system prompts
- Ask LLM to "check NXOpenTSE documentation for similar examples"

❌ DON'T:
- Copy code verbatim without attribution
- Replicate their library structure
- Import NXOpenTSE as a dependency (we build our own)
- Reuse their code without understanding it

Specific Areas to Reference

Our Component	NXOpenTSE Reference Area	What to Learn
nx_journals/update_and_solve.py	Expression handling, part updates	How to safely modify expressions
nx_journals/api_dispatcher.py	Session management	Best practices for NX session handling
mcp_server/tools/model_discovery.py	Part file reading	How to extract model information
optimization_engine/result_extractors/	CAE result reading	Methods for accessing simulation results

---

Using NXOpenTSE Documentation with MCP

MCP System Prompt Extension

When generating NXOpen code, the LLM can be instructed to:

When writing NXOpen code:
1. First check official Siemens NXOpen API docs for method signatures
2. Reference NXOpenTSE documentation (https://nxopentsedocumentation.thescriptingengineer.com/)
   for real-world usage patterns and best practices
3. Adapt patterns to our specific use case rather than copying directly
4. Always include error handling and validation
5. Add comments explaining NX-specific requirements

Example LLM Workflow

User: "I need to read all expressions from a .sim file"

LLM Reasoning:

1. Check official API: NXOpen.Part.Expressions
2. Look at NXOpenTSE example: https://nxopentsedocumentation.thescriptingengineer.com/expressions.html
3. See pattern: Loop through work_part.Expressions, handle edge cases
4. Adapt to our needs: Add filtering, type checking, JSON serialization

Generated Code (our implementation, inspired by reference):

def get_expressions(sim_file_path: Path) -> dict:
    """Extract all expressions from a .sim file."""
    import NXOpen

    session = NXOpen.Session.GetSession()

    # Load sim file
    part, status = session.Parts.OpenActiveDisplay(str(sim_file_path))

    expressions = {}
    try:
        for expr in part.Expressions:
            # Filter out system expressions (start with underscore)
            if not expr.Name.startswith("_"):
                expressions[expr.Name] = {
                    "value": expr.Value,
                    "units": expr.Units if expr.Units else "",
                    "type": str(expr.Type)
                }
    finally:
        # Clean up
        session.Parts.SetWork(None)

    return expressions

---

Additional Resources

3. Eng-Tips NXOpen Forum

URL: https://www.eng-tips.com/threadminder.cfm?pid=561

• Community Q&A
• Troubleshooting help
• User-contributed examples

4. Stack Overflow - NXOpen Tag

URL: https://stackoverflow.com/questions/tagged/nxopen

• Specific problem solutions
• Code snippets for common tasks

5. Siemens PLM Community Forums

URL: https://community.sw.siemens.com/

• Official support
• Product announcements
• Beta access information

---

Best Practices Learned from NXOpenTSE

1. Session Management

# Always get session at the start
session = NXOpen.Session.GetSession()

# Always check if part is loaded
if session.Parts.Work is None:
    raise ValueError("No work part loaded")

2. Error Handling

# Wrap NX operations in try-finally for cleanup
try:
    # NX operations here
    result = do_something()
finally:
    # Always clean up, even on error
    if temp_part:
        session.Parts.CloseAll(NXOpen.BasePart.CloseWholeTree.True)

3. Expression Updates

# Use Edit method for updating expressions
expr = part.Expressions.FindObject("parameter_name")
if expr:
    expr.Edit(new_value)
else:
    # Create if doesn't exist
    unit = part.UnitCollection.FindObject("MilliMeter")
    part.Expressions.CreateExpression(unit, "parameter_name", str(new_value))

4. Simulation Solution Access

# Access simulation objects safely
sim_simulation = sim_part.Simulation
if sim_simulation:
    solutions = sim_simulation.Solutions
    for solution in solutions:
        if solution.Name == target_name:
            # Found our solution
            pass

---

Attribution and Licensing

When Using Ideas from NXOpenTSE

1. Add attribution in comments:

   # Approach inspired by NXOpenTSE expression handling
   # See: https://nxopentsedocumentation.thescriptingengineer.com/expressions.html
   

2. Link in documentation:

   • Acknowledge inspiration in our docs
   • Link to relevant NXOpenTSE pages
   • Credit The Scripting Engineer for educational resources

3. Respect MIT License (verify current license):

   • Give credit to original authors
   • Don't claim their work as ours
   • Contribute back to community if we find improvements

---

Contributing to NXOpenTSE

If we discover useful patterns or fixes while building Atomizer:

• Consider contributing examples back to NXOpenTSE
• Report issues if we find documentation errors
• Share knowledge with the NX scripting community

---

Integration with Atomizer MCP

MCP Tool: search_nxopen_resources

{
  "name": "search_nxopen_resources",
  "description": "Search NXOpen documentation and reference materials",
  "inputSchema": {
    "query": "How to update expressions in NX",
    "sources": ["official", "nxopentse", "community"],
    "return_examples": true
  }
}

Output:

{
  "official_docs": "https://docs.sw.siemens.com/.../Expressions",
  "nxopentse_example": "https://nxopentsedocumentation.thescriptingengineer.com/expressions.html",
  "code_pattern": "Use part.Expressions.CreateExpression() or FindObject().Edit()",
  "community_threads": [...]
}

System Prompt Reference Section

## NXOpen Development Resources

When implementing NXOpen functionality:

1. **Official API**: Consult Siemens NXOpen .NET documentation for authoritative API reference
2. **NXOpenTSE**: Reference https://nxopentsedocumentation.thescriptingengineer.com/ for:
   - Practical usage patterns
   - Common parameter combinations
   - Error handling approaches
   - Real-world examples
3. **Adaptation**: Always adapt patterns to Atomizer's specific architecture rather than copying

Remember: NXOpenTSE is a reference for learning, not a dependency to import.

---

Summary

NXOpenTSE is invaluable for accelerating Atomizer development by:

• ✅ Showing proven patterns
• ✅ Teaching NX best practices
• ✅ Providing working examples to learn from
• ✅ Documenting edge cases and gotchas

We will use it as:

• 📚 Educational reference
• 🎯 Design pattern inspiration
• 🔍 Problem-solving resource
• 🧭 Navigation aid through complex NXOpen API

Not as:

• ❌ Code to copy-paste
• ❌ Dependency to import
• ❌ Replacement for understanding

This approach allows us to learn from the community while building something unique and tailored to Atomizer's specific optimization use case.

---

Last Updated: 2025-11-15 Maintainer: Atomaster Development Team