שילוב זרימות עבודה אוטומטיות של סימולציה עם ויזואליזציה תלת-ממדית לניסויים וירטואליים במטאברס

סיכום

שיטה כללית, התואמת ל-FAIR, מוצגת לחוקרים מומחים בתחום המעוניינים לשלב כלי סימולציה ועיבוד נתונים בתהליכי עבודה אוטומטיים לניסויים וירטואליים תלת-ממדיים. דוגמה לנייטרוניקה מדגימה הקמת מופע מקומי של Galaxy, עטיפת OpenMC וכלי המרת קבצים, הפעלת זרימות עבודה מ-Omniverse, והצגת הפלטים התלת-ממדיים המומרים.

תקציר

בניסויים וירטואליים רבים, נעשה שימוש בחבילות תוכנה מרובות עם סוגי סימולציה מגוונים, כלים לעיבוד קדם ואחרי, וכלים להמחשת תוצאות הניסויים—לעיתים קרובות שילוב של כולם. השיטה הטיפוסית לשילוב ביניהם היא ידנית, עם פתרונות מותאמים אישית שנוצרים לכל אזור יישום, מה שמתרחב בצורה גרועה ומקשה על שיתוף ושחזור.

פרוטוקול זה מדגים את הפריסה והשימוש במערכת זרימת עבודה מקומית במכולת. לאחר מכן, המשתמשים יפעילו מופע Galaxy מקומי באמצעות Docker, ייצרו ויריצו תהליך סימולציה של OpenMC לסימולציית נייטרונים, יעבירו את הפלטים דרך שרשרת של כלי המרת פורמט, ויטענו את התוצאות גם ל-ParaView וגם ל-NVIDIA Omniverse לצורך ויזואליזציה. פריסת המכולות מקדמת שחזוריות וניידות בכל מכונה העומדת בדרישות החומרה המתוארות בסעיף 1.

לאחר שהמערכת פועלת, ניתן להריץ מחדש זרימות עבודה מול קלטים חדשים ללא תצורה ידנית, ניתן לעטוף קודי סימולציה נוספים ככלים חדשים במאמץ מתון, וכלים יכולים לשמש בתהליכי עבודה ויישומים שונים. הגישה תומכת בעקרונות הנתונים הניתנים לאיתור, נגישות, אינטרופרביליים, רב-פעמיים (FAIR): היסטוריות ריצות לוכדות מטא-דאטה מלאה של המקור, תהליכי עבודה ניתנים לייצא כקבצים ניידים וניתן לשתף ישירות בין מופעי Galaxy, וכלים נארזים במכולות מבוקרי גרסאות שניתן לפרסם במאגר ציבורי. יכולת הרחבה למחשוב ביצועים גבוהים (HPC) או למשאבי ענן דרך מערכת הפולסר של גלקסי היא הרחבה טבעית לארכיטקטורה המתוארת כאן.

השיטה מודגמת באמצעות מחקר מקרה של נויטרוניקה מיזוג. OpenMC משמשת לסימולציה של העברת נייטרונים בגאומטריה בתכנון ממוחשב (CAD) בגיאומטריה מואצת ישירה במונטה קרלו (DAGMC), המפיקה תוצאה של יחס רבייה של טריטיום (TBR) ומאגר נתוני מעקב נייטרונים. זרימות העבודה של הסימולציה מחוברות אז ל-NVIDIA Omniverse כפלטפורמת המטאברס לקריאה והדמיה.

מבוא

המטאברס התעשייתי משלב עולמות דיגיטליים ופיזיים כדי לתמוך בעיצוב, סימולציה והמחשה תלת-ממדית שיתופית של מערכות מהונדסות. הוא בדרך כלל מורכב ממספר תאומים דיגיטליים מקושרים של רכיבים כדי לספק תצוגה כוללת של המערכת. ארגונים גדולים כמו בואינג, BMW, אמזון ועוד רבים נוקטים בגישות שונות ליצירת מטאברסים¹. פותחו מערכות לאפשרות שרשראות מרובות של סימולציה וכלי עיבוד והן בשימוש. עם זאת, דוגמאות אלו בדרך כלל מותאמות אישית לאזור^{יישום 2} או אופציות מסחריות ^3,4 עם נעילות מסוימת למערכות קנייניות. כמה חלופות קוד פתוח לבניית תאומים דיגיטליים שימשו ליצירת מערכות מסוימות, כמו Python Flask, עם יכולות סימולציה מובנות. עם זאת, אלה מוגדרים כקוד מותאם אישית לביצוע משימות ספציפיות הקשורות לדגם⁵ הספציפי. בהקשר של פרוטוקול זה, פלטפורמת המטאוורס (NVIDIA Omniverse) פועלת כחזית ויזואליזציה תלת-ממדית ואינטראקציה עם זרימת עבודה: פלטי סימולציה נטענים לסצנה משותפת לאחר סיום ריצת זרימת עבודה, וניתן להפעיל ריצות חדשות מתוך אותה סביבה. זה שונה ממערכות תאום דיגיטליות חיות שבהן זרמי חיישנים בזמן אמת מעדכנים את המודל באופן רציף; השיטה המודגמת כאן תומכת בביצוע זרימת עבודה באצווה ובחקירה לאחר ההרצה. עם זאת, הדבר נעשה כך שיתמוך בעבודה עתידית לשילוב מערכות נוספות בפלטפורמת המטאוורס כדי לאפשר יצירת תאומים דיגיטליים עם מנועי זרימת עבודה כחלק מהחישוב.

ניתן להגדיר זרימות עבודה כשרשראות של כלי תוכנה שמפרטות במפורש את זרימת הנתונים ביניהן. הם מאפשרים עטיפה של קודי סימולציה קיימים, סקריפטים של עיבוד ושלבים נוספים בצינור ניתוח טיפוסי, מבלי לשנות את הפונקציה שלהם, אלא מאפשרים להגדיר ולהגדיר אותם מחדש עם קלטים ויציאות סטנדרטיים שאינה תלויה בכלים. זרימות עבודה מאפשרות שכפול קל של תוצאות באמצעות שיתוף כלים, ומספקות גם מטא-דאטה ומקור לגבי אילו גרסאות כלים שימשו, באיזה סדר ועם אילו קלטים. כלים עצמם יכולים לשמש מחדש בצינורות סימולציה, מה שמאפשר לחוקרים להשקיע פחות זמן בהקמת סימולציות ויותר זמן בתכנון ניסויים וחקר התוצאות. מערכות זרימת עבודה גם ניתנות להרחבה, עם שיטות להתחבר למשאבי חישוב, ענן ו-HPC מקומיים שונים, המאפשרות להריץ זרימות עבודה בקנה מידה גדול על חומרה ספציפית באופן אוטומטי.

הגישה הידנית הטיפוסית היא איטית מטבעה, רגישה לשגיאות וקשה לשחזור, שבה חוקר מריץ כל כלי סימולציה או עיבוד פוסט-סימולציה ידנית, מעביר קבצים ביניים בין סביבות, וצריך לתעד קלטים ופלטים בודדים. בניגוד לכך, מנהל זרימת עבודה פורמליזציה של זרימת הנתונים פעם אחת ומריץ אותה מחדש באופן דטרמיניסטי. זה מביא יתרונות רבים ביחס לצינורות ידניים: אותו תהליך עבודה יכול להתבצע באופן זהה על קלטים שונים, ותומך במחקרי פרמטרים ללא סקריפטינג מותאם אישית; כל ריצה לוכדת אוטומטית מטא-דאטה מלאה של המקור, ומטפלת בכל פער בשחזוריות; וברגע שכלי נעטף, עלות השימוש החוזר שלו בתהליכים הבאים יורדת כמעט לאפס, מלבד זמן החישוב. יתרונות אלו נמדדו בביואינפורמטיקה על ידי Wratten ואחרים.7 ועבור פרוטאומיקה/מטבולומיקה על ידי Perez-Riverol ו-Moreno⁸ ו-Verhoeven et ^al.9.

היסטורית, תהליכי עבודה שימשו בעיקר בתחום הביואינפורמטיקה ^8,9 בהצלחה רבה עם מופעים ציבוריים גדולים כמו שרת Galaxy האירופי^10,11, שבשנת 2022 אירח יותר מ-50,000 משתמשים, 2500 כלים, ביצע מעל 47 מיליון עבודות ו-260,000 ריצות זרימת עבודה. אותה ערימת מנוע זרימת עבודה תומכת בהרחבה ל-HPC ולמשאבי ענן דרך מערכת ביצוע משימות מבוזרת של Pulsar ^6,11, עם פריסות תפעוליות הכוללות 13 נקודות קצה של Pulsar ב-10 מדינות אירופה. מבין מנהלי זרימת העבודה הרבים הזמינים, כולל Snakemake, Nextflow, Toil ומנועים תואמי CWL, מנוע זרימת העבודה Galaxy¹¹ נבחר ממספר סיבות. אחת הסיבות העיקריות לכך היא הממשק הבוגר המבוסס על דפדפן, שמפחית את מחסום הכניסה למומחי תחום שאינם עובדים בעיקר בשורת הפקודה; הוא חושף ממשק תכנות יישומים (API) מלא להעברת מצב ייצוג (REST) (המשמש בעבודה הנוכחית לגשר לצד החזית של המטאברס); מודל ההיסטוריה וה-Jobs שלו לוכד את המקור בצורה שקל לחשוף בפני שותפים שאינם מומחים; והוא תומך בפריקת HPC שקופה דרך מערכת הפולסר שהוזכרה קודם (אם כי זה לא נדון בסעיף הפרוטוקול במאמר זה). עם זאת, הגישה המתוארת במאמר זה היא עיקרונית שאינה תלויה במנועי זרימת עבודה: ניתן לבנות אינטגרציות שוות ערך על גבי מנועים חלופיים. התרומה של עבודה זו אינה מנהל זרימת העבודה עצמו אלא תרגום של מנהל זרימת עבודה כללי שפותח במקור לביואינפורמטיקה לתחומים אחרים (עם הדוגמה הספציפית של נייטרוניקת מיזוג כאן), ואינטגרציה עם פלטפורמת מטאברס תעשייתית (NVIDIA Omniverse), בתוך מחסנית מכולות מלאה וניתנת לפריסה מקומית, המיושמת בניסויים וירטואליים תלת-ממדיים.

לבסוף, המכולות מאפשרת שיתוף של חלקים רבים של תוכנה על ידי אריזת קוד עם מערכת ההפעלה וכל התלות שהיא צריכה להריץ. סביבות אלו נמנעות מבעיות של תלות חסרה ומהטרחה של התקנת קודי סימולציה. הן דומות במטרתן למכונות וירטואליות אך הרבה יותר קלות וניידות יותר. הם מגדילים משמעותית את השיתוף והשחזור של חבילות תוכנה. בשיטה זו, מנהל זרימת העבודה והכלים הבודדים פועלים במכולות Docker¹² , מה שמגביר את התאימות למערכות הפעלה שונות כל עוד המשתמש יכול להריץ מכולות.

פרוטוקול זה מיועד לחוקרים מומחים בתחום, לדוגמה, מהנדסי נייטרוניקה מיזוגים, אנליסטים של דינמיקת נוזלים חישובית, או מתרגלים של אלמנטים סופיים, ששולטים בכלי הסימולציה של תחומם אך לא השתמשו בעבר במנהל זרימות עבודה או בפריסה מבוססת מכולה. מניחים היכרות עם קוד סימולציה יחיד ופעולת שורת פקודה בסיסית; היכרות עם גלקסי או האומניברס אינה כזו. קוראים חדשים בתחום המכולות צריכים לעיין בתיעוד הרשמי של Docker (https://docs.docker.com/) או בהכשרה מבוא הזמינה בכתובת: https://uomresearchit.github.io/docker-introduction/ לפני ביצוע סעיף 1; הפקודות הבסיסיות הנדרשות להפעלת התוכנה כלולות כולן בתוך הפרוטוקול.

שאר הדוח יכסה את ההקמה והשימוש במערכת הניתנת לפריסה מקומית. לאחר מכן, יבוצע שלבים לפיתוח כלים חדשים למערכת ושיטה לקישור חבילות חיצוניות נוספות למנוע זרימת העבודה, כמו פלטפורמת מטאברס. במהלך הדוח, סימולציה של נייטרוניקה באמצעות OpenMC¹³ משמשת כמחקר מקרה. OpenMC נבחר כי הוא מציג את כל צינור הוויזואליזציה מ-CAD-לסימולציה-לפלט, שמניע את ארכיטקטורת זרימת העבודה. קובץ גיאומטריה וקובץ קונפיגורציה משמשים כקלטים מובנים; סימולציית העברת הנייטרונים במונטה קרלו מייצרת מדד סקלרי (יחס רבייה של טריטיום, TBR) שניתן להשוותו לטווח ידוע של ערכים, ומערך נתונים של מסלול נייטרונים מפותח מרחבית שניתן לעבד ולהציג בפורמט ויזואלי עבור ההדמיה התלת-ממדית ביישום המטאברס.

פרוטוקול

הערה: סקירה של הגדרת מנוע זרימת העבודה המקומי, בניית זרימת עבודה, השקת זרימת עבודה ויצירות ויזואליזציה מוצגת באיור 1, איור 2, איור 3, איור 4, איור 5, איור 6, איור 7 ואיור 8. קבצי המאגר הנדרשים להפעלת הפרוטוקול מסופקים בקובץ המשלים 1.

1. הכנה

1. דרישות
   הערה: שיטה זו נבדקה בגרסת התמיכה לטווח ארוך (LTS) האחרונה של אובונטו, 22.04.1 LTS. גרסאות אחרות של אובונטו והפצות אחרות עשויות לעבוד, אך הן לא נבדקו כאן. הוא פועל גם על מערכות Windows, תוך שימוש ב-Windows Subsystem for Linux (WSL) כצד האחורי של Docker.
   1. משתמשי Windows: הורידו את WSL והגדרו אותו, כי זה דרישה ל-Docker.
   2. הורד את Docker ואז בדוק על ידי הרצה:
      `דוקר רץ הלו-וורלד'
      שצריך להציג הודעת קבלת פנים.
   3. הורד את המשגר של NVIDIA Omniverse ואחת מהאפליקציות של Omniverse דרך המשגר.
      הערה: הרינדור בזמן אמת של NVIDIA Omniverse עם עקבות קרניים דורש כרטיס גרפי ברמת RTX. משתמשים ללא חומרה זו עדיין יכולים להריץ את כל זרימת העבודה דרך סעיף 2 ולבדוק את הפלטים הביניים של .vtk / .vtp ב-ParaView (ראו דיון). משתמשים אלו יכולים לדלג על סעיף 3, שכן הוא מתייחס רק לפלטפורמת המטאברס; השיטות לשילוב מנוע זרימת העבודה כאן עשויות להיות שימושיות אם מתחברים לפלטפורמות מטאברס אחרות.
      הפרוטוקול הזה משתמש בקוד Omniverse של האפליקציה, אך שאר אפליקציות Omniverse צריכות להיות דומות במידה רבה. למרות שאינו חיוני, ניתן להשתמש ב-ParaView כדי להמחיש חלק מהקבצים הביניים שנוצרים על ידי הכלים בפרוטוקול זה.
2. מאגר
   1. שכפל את המאגר המכיל את כל הקבצים והסקריפטים הנדרשים למופע מנוע זרימת העבודה המקומי והכלים המתוארים במאמר זה עם:
      'שיבוט https://github.com/williamjsmith15/galaxy-omniverse-example.git'
   2. הוסף אימייל מנהל לרשימת משתמשי המנהל.
      הערה: זה ייתן הרשאות מנהל הנדרשות לחלק מתכונות מנוע זרימת העבודה וניתן למצוא אותו בסעיף admin_users בקובץ galaxy-config/galaxy.yml (ראו https://github.com/williamjsmith15/galaxy-omniverse-example/blob/master/galaxy-config/galaxy.yml).
   3. שנה את שם קובץ ה-default.json.template ל-default.json. קובץ זה ממוקם בכתובת omni_exts/omni.galaxy.example/omni/galaxy/example/default.json.template.
      הערה: זה יאפשר לקרוא אותו על ידי התוסף של פלטפורמת המטאוורס ולאפשר להוסיף ולשמור הגדרות אישיות בין טעינות—שינויים נוספים ייעשו לאחר הגדרת מופע הגלקסי.
3. הפעלת שרת מנוע זרימת עבודה מקומי
   1. הפעל את מופע מנוע זרימת העבודה על ידי הרצת קובץ start-galaxy.sh ברמה העליונה של המאגר:
      './start-galaxy.sh'
      אם הקובץ לא רץ כאן, ייתכן שיהיה צורך להפוך אותו לביצועי אם ההרשאות השתנו בשכפול המאגר. ניתן לעשות זאת על ידי ריצה:
      'CHMOD A+X start-galaxy.sh'
      הערה: משתמשי Windows חייבים לעשות זאת דרך טרמינל WSL שלהם. זה יוריד את הקבצים הרלוונטיים ויפעיל את מופע מנוע זרימת העבודה, שניתן לצפות בו ב-http://localhost:8080 בכל דפדפן שרץ על אותו מחשב. זה אמור להציג את העמוד המוצג באיור 1; אם לא, חכה ורענון—ייתכן שמנוע זרימת העבודה ייקח זמן לפעול (במיוחד בפעם הראשונה).
      1. באופן כללי, כדי לראות את השינויים שנעשו במאגר במופע מנוע זרימת העבודה, הרץ את './restart-galaxy.sh' או './stop-galaxy.sh', ואז הפעל את הסקריפט מחדש.
4. תצורת פלטפורמת המטאוורס
   1. פתח את האפליקציה לאחר הורדת המשגר והאפליקציה (לדוגמה, קוד Omniverse).
   2. בפינה השמאלית העליונה של החלון, לחצו על לשונית ההרחבות (באפליקציות אחרות, זה יהיה תחת Window | הרחבות).
   3. בחלון ההרחבות , לחץ על כפתור ההגדרות האפור; זה יפתח חלון עם כמה מדריכים שכבר מאוכלסים. הוסף עוד אחד שמצביע על תיקיית omni_exts על ידי לחיצה על כפתור הפלוס הירוק והוסף נתיב שיכלול את הפורמט: '<שורש של ריפו משוכפל>/galaxy-omniverse-example/omni_exts'; ראו איור 2 לפרטים נוספים.
   4. חפשו ערך חדש בשם 'OMNI GALAXY EXAMPLE' בעמודה השמאלית תחת לשונית THIRD PARTY . הפעילו את הסליידר של התוסף הזה והמתינו שחלון ההרחבה יופיע.
   5. בחר בתיבת הטעינה האוטומטית כדי לטעון את התוסף אוטומטית בכל פעם שהאפליקציה מופעלת.
      הערה: שינויים שנעשו בקבצי ההרחבה אמורים להישמר אוטומטית כאשר הקובץ נשמר, שכן Omniverse מאפשר טעינה חמה של הרחבות
5. יצירת חשבון במנוע זרימת עבודה וקישור למטאברס
   1. במופע מנוע זרימת העבודה, צור חשבון על ידי לחיצה על כפתור ההתחברות או ההרשמה בסרגל העליון, ואז Register Here, ואז מלא את הפרטים באמצעות כתובת האימייל שנוספה בשלב 1.2.2 כדי ליצור חשבון עם גישה למנהל.
   2. יצר מפתח API שיאפשר ל-API לתקשר עם מנוע זרימת העבודה. עבור לתפריט הנפתח של המשתמש בסרגל העליון | העדפות | ניהול מפתח API. צור מפתח והעתיק אותו.
   3. לאחר שהמפתח נוצר, הוסף אותו לקובץ default.json שנוצר בשלב 1.2.3 תחת שדה 'galaxy_api_key' במרכאות הריקות.
      אזהרה: קובץ זה יחזיק כעת מפתח API. מפתח API זה יכול לשמש להרצת עבודות וגישה לנתונים בחשבון המשויך. זה לא אמור להיות בעיה בפריסה מקומית שבה אין דומיין ציבורי או כתובת IP; קובץ זה עדיין צריך להיחשב כסודי ולכן לא משותף או נשמר למאגר ציבורי (הקובץ מופיע כברירת מחדל בקובץ .gitignore כדי להתמודד עם זה).
   4. הפעל מחדש את אפליקציית פלטפורמת המטאוורס כדי לרענן את השינויים שנעשו בקובץ ברירת המחדל.
      הערה: מפתח ה-API יכול גם להיות מוסף ישירות לחלון ההרחבה תחת תפריט הגדרות השרת, אם כי זה לא יישאר בין הסשנים.

2. הרצת עבודות במנוע זרימת העבודה

1. כלים בודדים
   הערה: כלים בודדים מאפשרים להריץ ולבדוק שלבי עיבוד או סימולציה בודדים בנפרד, דבר שימושי לאימות שהקלטים מעוצבים כראוי ושהכלי פועל כמצופה לפני שילובו בתהליך עבודה. קבצי הבדיקה המוזכרים להלן, dagmc.h5m (גאומטריית DAGMC CAD) ו-openmc_config.json (תצורת הסימולציה), נמצאים בתיקיית test_files של המאגר המשובלט.
   1. העלה את קבצי הקלט הנדרשים על ידי לחיצה על העלאת נתונים בעמודה השמאלית ובחר או לבחור קבצים מקומיים או לגרור ולשחרר מסייר קבצים לחלון זה. העלה את קובץ ה-dagmc.h5m (קובץ ה-CAD) ואת openmc_config.json (קובץ הקונפיגורציה), ואז לחץ על כפתור ההתחלה כדי להעלות להיסטוריה הנוכחית. שני הקבצים יופיעו בירוק בפאנל ההיסטוריה מימין כאשר ההעלאה תושלם.
   2. בחר את תפריט הנפתח Complex Tools בעמודה השמאלית של דף הנחיתה ואז את כלי הסימולציה של OpenMC Neutronics .
   3. כעת בדף הספציפי לכלי, בחר את הקלטים מהקבצים שהועלו בשלב 2.1.1 ובחר את קובץ ה-CAD כמערך הנתונים dagmc.h5m ואת קובץ הקונפיגורציה כמערך הנתונים openmc_config.json .
   4. לחץ על כפתור הביצוע . שני קבצים חדשים (TBR ו-Tracks) יופיעו בפאנל ההיסטוריה מימין למסך. הם יהפכו לכתומים בזמן הרצה, וירוקים כשהם מושלמים ומצליחים, אדום יסמן תקלה בכלי העבודה. ראו סעיף 4 לשלבי איפוי שגיאות.
   5. ערך ה-TBR (יחס רבייה של טריטיום) ניתן להמחשה כדי לוודא שמקרה הבדיקה בוצע בהצלחה. לחץ על פלט ה-TBR להרחבה, ואז על אייקון הגרף, ואז על העורך. זה יביא את תוצאת ה-TBR, שצריכה להיות סביב 0.76 (זו שיטה סטטיסטית, והקונפיגורציה כאן משתמשת בגודל מדגם קטן למהירות הסימולציה, כך שהתוצאות ישתנו).
      הערה: ערך ה-TBR הוא סטוכסטי; ערך 0.76 עשוי להשתנות ב-±0.01 וזה משקף מספר חלקיקים קטן במכוון (5 קבוצות של 1,000 חלקיקים) שנבחרו עבור תהליכי עבודה מהירים לדוגמה. כדי לצמצם את טווח הערכים, הגדילו את מספר האצווה והחלקיקים תחת שדה ההגדרות בקובץ openmc_config.json לפני הרצה מחדש. כהנחיות לגאומטריה פשוטה כמו המקרה המוצג כאן, 50 קבוצות של 10,000 חלקיקים אמורות להפחית את פיזור ערכי ה-TBR בריצות הבאות במחיר של זמן ריצה ארוך יותר.
   6. כלים אחרים יכולים להריץ על פלט Tracks של תהליך העבודה כדי לעבד את התוצאות. הרץ את כלי h5 ל-vtp של Tracks על פלט Tracks ואז את כלי ה-CAD h5m ל-vtk בקובץ הקלט dagmc.h5m. שניהם יפיקו פלט אחד, tracks_0.vtp ו-dagmc.vtk, שממיר אותם לפורמט שניתן להמחיש בקלות רבה יותר.
   7. הפלטים שנוצרו בשלב הקודם ניתנים להורדה מהאינסטנס (על ידי לחיצה על הפלט ואז על סמל השמירה) ואז ניתן להמחיש אותם ב-ParaView¹⁴ כדי לראות את מסלולי הנייטרונים המדומים.
   8. כדי להמחיש את התוצאות ב-ParaView, ייבא את הפלטים tracks_0.vtp ו-dagmc.vtk שהורדו. אלה יופיעו בצד שמאל של החלון. לחצו על אייקון העין ליד הקבצים המיובאים או על כפתור Apply למטה בחלון התכונות כדי להמחיש את הפלט. זה אמור להיות דומה למה שנראה באיור 7.
2. תהליכי עבודה
   הערה: זרימת עבודה מקודדת צינור עיבוד מלא כגרף מכוון של כלים עם קלטים ופלטים מוצהרים. לאחר ההגדרה, אותו תהליך עבודה יכול להיות מופעל מחדש על כל קבוצת קבצי קלט מבלי להגדיר מחדש ידנית כל כלי, וכל מטא-נתוני היסטוריית הריצה והמקור נלכדים אוטומטית.
   1. לחץ על Workflow בשורת הניווט העליונה, ואז על Create בפינה הימנית העליונה. הזן שם ותיאור לתהליך העבודה (כל דבר יעבוד), ואז לחץ שוב על יצירה .
   2. הוסף שלושה כלים לזרימת העבודה, הרחיב את החלקים הרלוונטיים בתפריט הכלים והוסף את הכלים שבסעיף 2.1: OpenMC Neutronics Simulation, CAD h5m ל-vtk ו-Tracks h5 ל-vtp.
   3. הגדר את זרימת הנתונים בין הכלים. גרור את הכלים סביב סביבת העבודה על ידי לחיצה וגרירת הסרגל העליון הכחול הכהה של כל אחד מהם. חבר את יציאת Tracks (h5) של כלי הסימולציה של הנייטרוניקה לקלט Tracks.h5 של כלי h5 ל-vtp. עשה זאת על ידי לחיצה וגרירה מהחץ בפלט לחץ בקלט.
   4. הגדר את מערכי הנתונים הקלטים ברמת זרימת העבודה. בחלק הקלטים של הכלים, לחץ פעמיים על מערך נתונים קלט כדי ליצור שני צמתים קלט. שנה את שם אחד לקובץ הקונפיגורציה ואת השני לקלט ה-CAD על ידי לחיצה על השלב ואז שינוי שדה התווית בתפריט המאפיינים הימני.
   5. קשר את קובץ הקונפיגורציה ואת קובץ ה-CAD לקלטים בכלי הסימולציה של הנייטרוניקה, ואת קובץ ה-CAD לכלי h5m ל-vtk, בהתאם לדפוס באיור 3.
   6. שמור את תהליך העבודה באמצעות סמל השמירה בפינה הימנית העליונה.
   7. כדי להריץ את זרימת העבודה, לחץ על לשונית זרימת העבודה בסרגל העליון כמו קודם, ואז לחץ על אייקון ההפעלה בזרימת העבודה שיש להריץ. לאחר מכן בחר את הקלטים כמו בשלב 2.1.2, כמו אם מריץ כלי, ולחץ על הרצת זרימת עבודה.
   8. חכה שתהליך העבודה ירוץ, ואז ניתן להשוות את הפלטים לשלבים 2.1.5 ו-2.1.8; אלה אמורים להיות דומים מאוד (שוב, שימו לב לשונות הסטטיסטית מהשלבים האלה). תהליך העבודה רץ בהצלחה כאשר כל הפלטים בהיסטוריה הפכו לירוקים. אמורים להיות (יחד עם מערכי הנתונים הקלטיים) ארבעה מערכי נתונים כאן: TBR, Tracks, dagmc.vtk ו-tracks_0.vtp.
   9. ככל שזרימת העבודה הופעלה, חלק מהמשתמשים עשויים לרצות לראות את המקור והמטא-דאטה שנלכדו של ההפעלה של זרימת העבודה. ניתן להשיג זאת על ידי ניווט למשתמש בסרגל העליון | Workflow Invocations. כתוצאה מכך, רשימת כל תהליכי העבודה שמופעלים על ידי המשתמש, לוחצים על החץ כלפי מטה בזרימת העבודה הרצויה ואז ניתן להוריד את קובץ המטא-דאטה JSON על ידי לחיצה על כפתור Download BioCompute Object . זה מכיל מקור של הכלים/זרימות העבודה שהופעלו, הקלטים שהשתמשו בהם וכו'.
      הערה: מנוע זרימת העבודה גם רושם היסטוריית ריצה מלאה לכל ביצוע זרימת עבודה, כולל סכומי בדיקה של קבצי קלט, גרסאות כלי וערכי פרמטרים. כדי להוריד את רשומת המקור של ריצה, פתח את לוח ההיסטוריה , לחץ על התפריט (חץ למטה) בפינה הימנית העליונה, ובחר ייצוא היסטוריה לקובץ. הארכיון המיוצא מכיל את כל מערכי הנתונים ורשומה קריאה במכונה של השלבים שיצרו אותם.
      שמירת המקור או ההיסטוריות שנוצרו על ידי מנוע זרימת העבודה יכולה להיות אוטומטית באמצעות ה-API שנדון בסעיף 5.1; עם זאת, הוא לא יפרט בפרוטוקול זה.
3. תהליך עבודה מורכב יותר
   הערה: תהליך עבודה זה מרחיב את סעיף 2.2 על ידי הוספת שלבי עיבוד לאחר שמייצרים קבצי תיאור סצנה אוניברסלי (USD) הנדרשים להמחשה בפלטפורמת המטאברס. מכיוון שאף כלי יחיד לא ממיר ישירות מ-DAGMC (.h5m) או VTK (vtp) ל-USD, הצינור מנתב נתונים דרך שתי שרשראות המרה רב-שלביות: גאומטריית CAD עוקבת אחרי צינור H5M, STL, OBJ, USD, ומסילות הנייטרונים עוקבות אחרי H5, VTP, OBJ, USD.
   1. עקבו אחר השלבים להגדרת תהליך עבודה, כפי שמוצג בסעיף 2.2, בהתאם לתהליך העבודה המוצג באיור 4.
   2. הגדר את שני הקלטים ברמת זרימת העבודה כפי שמופיע בשלב 2.2.4, וקרא להם CAD DAGMC וקובץ קונפיגורציה.
   3. הוסף את כלי OpenMC Neutronics Simulation וחבר את קלטי DAGMC וקובץ הקונפיגורציה CAD לכניסות המקבילות כפי שמופיע בשלב 2.2.3.
   4. צור את שרשרת ההמרה לנייטרוניקה. הוסף את ה-Tracks h5 ל-vtp, vtp ל-obj, ו-obj לכלי USD ואז חבר את הפלטים של כל כלי לקלטים של הבא, בהתאם לפריסה בסניף התחתון של איור 4.
   5. צור את שרשרת ההמרה של CAD. הוסף את ה-h5m ל-STL, את ה-STL ל-OBJ, ואת הכלים של OBJ ל-USD, ואז שוב חבר את הפלטים של כל כלי לקלט של הבא, בהתאם לפריסה בסניף העליון של איור 4.
   6. שמור את זרימת העבודה, שכעת מוכנה לשימוש בפלטפורמת המטאברס דרך ההרחבה בסעיף 3.
      הערה: השלבים הנוספים הללו מראים למשתמשים כיצד ניתן לשתף תהליכי עבודה וכלים, ומאפשרים שכפול ונגישות לנתונים ולשיטות המשמשים ליצירת תוצאות.
   7. ייצוא את זרימת העבודה כקובץ נייד על ידי ניווט ל-Workflow בסרגל העליון, לחיצה על התפריט (חץ כלפי מטה), ובחירה בהורדה. מנהל זרימת העבודה שומר קובץ JSON ב-.ga , שניתן לשתף ולהשתמש בו על ידי כל אחד עם אותם כלים במופע מנוע העבודה שלו. ניתן לייבא זאת דרך Workflow בסרגל העליון | ייבוא.
   8. שתפו כלים על ידי הפקדת ה-galaxy-tools/ תיקיית המאגר המשובט למארח בקרת גרסאות ציבורי. בקש מהשותפים לשכפל את זה כדי לקבל גישה לכל הכלים המכולים, להריץ אותם באותו אופן כמו במכשיר המקומי של המפרסם.
      הערה: ניתן להגדיר מופעי מנהל זרימת עבודה ציבוריים, מה שמונע שיתוף ידני של קבצי זרימת עבודה וכלים בין פריסות מקומיות. במקרים אלו, הכלים נגישים לכל המשתמשים, ותהליכי עבודה והיסטוריות יכולים להיות פומביים לכל שאר המשתמשים. זה מחוץ להיקף הפרוטוקול הזה, אך מידע נוסף ניתן למצוא ברשת הרשמית של Galaxy Training על קבלת פריסה קבועה: https://training.galaxyproject.org/training-material/topics/admin/tutorials/ansible-galaxy/tutorial.html או מחסנית docker compuse שמופיעה במאגר יכולה להיות מופעלת כפי שהיא על שרת ואז לנתב באמצעות פרוקסי או אמצעים דומים כדי להפוך אותה לנגישה לציבור.

3. הרצת זרימת עבודה מפלטפורמת המטאוורס

1. השקת תהליך העבודה
   1. בחלון ההרחבה של פלטפורמת המטאברס, לחץ על קבל זרימות עבודה (הערה 2, איור 5). תפריט נפתח ימלא את כל תהליכי העבודה הזמינים בחשבון מנוע זרימת העבודה המשויכים למפתח ה-API המאוחסן ב-default.json. אם זה לא המצב, בדוק שמפתח ה-API נשמר נכון בקובץ ה-JSON, והפעל מחדש את אפליקציית פלטפורמת המטאברס כדי לוודא שהיא מזהה את המפתח.
   2. בחר את תהליך העבודה המורכב של הרשימה ואז לחץ על קבל קלטים (הערה 4, איור 5). שדות הקלט המוגדרים בזרימת העבודה (שלב 2.3.2) יופיעו וצריכים לקבל את השמות באותו שם.
   3. לכל קלט מבוסס קבצים, לחץ על Select File והשתמש בחלון סייר הקבצים כדי לבחור את הקובץ המקומי המתאים: dagmc.h5m לקלט CAD DAGMC ו-openmc_config.json לקלט קובץ הקונפיגורציה .
   4. לחץ על הפעלת זרימת עבודה (הערה 6, איור 5). הודעת אישור השקה תוצג בסעיף המידע (הערה 7). לאחר סיום תהליך העבודה, הודעות נוספות יאשרו שקבצי הפלט נשמרו ושהריצה הסתיימה.
      הערה: ניתן לעקוב אחר התקדמות העבודה בתהליך העבודה בממשק האינטרנט של מנוע זרימת העבודה http://localhost:8080 על ידי ניווט ל-Admin | Jobs. נדרש גישה ממנהל (ראו שלב 1.2.2).
2. המחשת התוצאות
   הערה: עם סיום כל הרצת זרימת עבודה, המערכת מורידה אוטומטית את קבצי הפלט ממנוע זרימת העבודה לתיקיית פלט מקומית. מסלול השמירה נשלט על ידי מפתח output_dir בקובץ default.json של התוסף. כל ריצה נשמרת בתיקייה עם חותמת זמן, כך שניתן להבחין בין הפלטים לפי התוסף. אם יש בעיות בוויזואליזציה בפלטפורמת המטאברס, ניתן לגשת לקבצים בתיקיות אלו ולצפות בהם ידנית כדי לבדוק אם הבעיה היא במנוע זרימת העבודה.
   1. בפלטפורמת המטאברס, הרחב את סעיף מנהל הקבצים (הערה 1, איור 6) ולחץ על רענון (הערות 2). זה משחזר את רשימת הריצות של זרימת העבודה שהושלמה שנשמרו בתיקייה המקומית.
   2. בתפריט הנפתח של התיקיות (הערה 3, איור 6), בחר את התיקייה לרצת זרימת העבודה הנוכחית (אשר זו היחידה שם כרגע) ולחץ שוב על רענון כדי למלא את תפריט הקבצים בפלטים מהרצה הזו.
   3. בחר קובץ מתוך תפריט הקבצים (הערה 4, איור 6; כיום נתמכים רק קבצי .usd, .txt, .json ו -.out ) ואז לחץ על Pull File (הערה 5). קבצים מבוססי טקסט מוצגים בפאנל המידע , קבצי USD מתווספים לסצנה הנוכחית, ויש להמחיש אותם בתמונה הראשית.
   4. כדי ליישר את הגיאומטריה המיובאת עם קונבנציה הקואורדינטות של Omniverse, פתח את לוח ה-Stage בצד ימין, בחר את שני אובייקטי זרימת העבודה המיובאת, ובלוח התכונות שמתחתיו הגדר את Rotate X ל-−90°. זה מתקן את חוסר ההתאמה בין קונבנציה z-up שבה משתמשים כלי הייצוא של USD לבין קונבנציה y-up של Omniverse. יישם סיבוב זה גם על דולר ה-CAD וגם על קובץ ה-tracks USD; מצב החלון הצפוי לאחר היישור מוצג באיור 8.
   5. לבסוף, כדי לקבל יותר ניגודיות בין החלקים, ניתן להקצות חומרים. זה מושג על ידי פתיחת לשונית החומרים בתחתית האפליקציה, בחירת חומר, ואז גרירה ושחרור על הגיאומטריה בתצוגת הבמה בעמודה הימנית. עשה זאת עבור שתי הגיאומטריות המיובאות כדי להגדיל את הניגודיות ביניהן.

4. הוספת כלים חדשים

הערה: סעיף זה מתאר את תהליך המפתחים ליצירה ופריסה של כלי עבודה חדשים. הוא דורש גישה למערכת הקבצים של המאגר, וגישה של מנהל למנוע זרימת העבודה לניפוי שגיאות. משתמשים שצריכים רק להריץ כלים ותהליכי עבודה קיימים, או ליצור זרימות עבודה, אינם חייבים לעקוב אחרי סעיף זה.

1. תהליך כללי
   1. פתח ובודק את הסימולציה או סקריפט העיבוד באופן עצמאי ממנוע זרימת העבודה לפני העטיפה שלו. עטיפת הכלים קוראת לסקריפט עבודה קיים, אך לא מומלץ ליישם לוגיקה חדשה תוך כדי פיתוח כלי.
   2. הכינו את סביבת ההרצה לסקריפט על ידי יצירת תמונת Docker הכוללת את כל התלות בזמן ריצה (ספריות, קבצים בינאריים, קבצי נתונים וכו') הנדרשות על ידי הסקריפט.
      הערה: כל כלי הדוגמה בפרוטוקול זה משתמשים בקונטיינרים של Docker כסביבת הביצוע. סביבות קונדה נתמכות גם הן על ידי מנוע זרימת העבודה אך אינן מוצגות כאן. מידע נוסף על דוקר ניתן למצוא דרך התיעוד הרשמי, או קורס מבוא טוב ניתן למצוא כאן: https://uomresearchit.github.io/docker-introduction/ .
   3. צור קובץ הגדרת כלי XML שמצהיר על סביבת ההרצה (במקרה זה Docker), את הפקודה להפעלת הסקריפט, ואת הקלטים, הפלטים והמטא-דאטה של הכלים להצגה בממשק של מנוע זרימת העבודה.
   4. לאחר יצירת העטיפה, הנח את ה-XML וכל הסקריפטים בתיקייה חדשה בשם galaxy-tools// במאגר. הוסף ערך חדש לכלי ב-galaxy-tools/tool_conf.xml תחת תגיות
      המתאימות, המצביע על נתיב הקובץ היחסי של קובץ XML שנוצר לאחרונה.
      הערה: ודא ששם הקובץ הזה מועתק במדויק, שכן זו שגיאה נפוצה כשמנסים לפרוס כלים חדשים. אם הערך tool_conf.xml מכיל נתיב שגוי או שלקובץ ה-XML יש שגיאת תחביר, מופע מנוע זרימת העבודה ייכשל להתחיל. כדי לבדוק את יומני מיכל זרימת העבודה לאיתור הודעות שגיאה, הרץ את הדברים הבאים מהשורש של המאגר:
      'דוקר קומפוז לוגים גלקסיה'
      שגיאות ניתוח XML מופיעות כשורות בכלי טעינת ERROR
   5. פרוס מחדש את מנוע זרימת העבודה כדי לטעון את הכלי החדש על ידי הרצת סקריפט ההפעלה מחדש מהשורש של המאגר: ./restart-galaxy.sh.
   6. אשר שהכלי נרשם כראוי. נווט ל-http://localhost:8080, מצא את הכלי בפאנל הכלים ולחץ עליו כדי לוודא שכל הקלטים מופיעים כמצופה. אם הכלי נעדר, עקוב אחרי ההערה למעלה לניפוי שגיאות, ואם עדיין יש שגיאות, בדוק את התחביר של ה-XML עצמו כי זה עלול לגרום גם לשגיאות פריסה.
   7. הרץ את הכלי החדש כמו קודם, אבל עם קלטים שנבדקו בעבר. הפלטים אמורים להפוך לירוקים בפאנל ההיסטוריה
   8. אם הכלים נכשלו, אז כמנהל, לחץ על הפלט הכושל (אדום) ולחץ על אייקון המידע . זה מציג דף פלט מפורט ומציג את זרמי stdout ו-stderr. ניתן להרחיב אותם למידע נוסף על ניפוי שגיאות בכלי.
2. כלים פשוטים
   הערה: כלים 1–5 ממחישים דפוסי עטיפה מורכבים יותר ויותר. קובץ ה-XML וכל סקריפטים לכל כלי נמצאים בתת-תיקיית galaxy-tools/simple// המתאימה במאגר. פרוס והפעיל כל כלי לפי שלבים 4.1.4–4.1.5 וסעיף 2.1.
   כלי 1 – הרצת פקודה פשוטה
   1. תסתכל על קובץ galaxy-tools/simple/1/1.xml . אלמנט הדרישות מגדיר סביבת ביצוע לינוקס. רכיב הפקודה מכיל את פקודת הד להרצה.
   2. הרץ את Tool 1 מממשק מנוע זרימת העבודה ללא צורך בקבצי קלט. מכיוון שאין גם קבצי פלט מוגדרים, כמנהל, עבור לדף Admin, Jobs ואז לחץ על סמל המידע כדי לראות את זרמי stdout ו-stderr, שזה זהה לזה שבשלב 4.1.8. זרם stdout אמור להכיל רק את מחרוזת 'hello world' מהפקודה בקובץ ה-XML.
      כלי 2 – שימוש בקלט מבוסס טקסט
   3. תסתכל על קובץ galaxy-tools/simple/2/2.xml . כעת יש רשומה בשדה הקלט , עם אלמנט פרם type="text" וחלק הפקודות מתייחס למשתנה הקלט באמצעות תג השם.
   4. הרץ את Tool 2 כמו קודם; הפעם, תן לכלי קלט של מחרוזת. זה יכול להיות כל דבר שהמשתמש ירצה. צפה בפלט כפי שמופיע בשלב 4.2.2, ויציאת ה-stdout צריכה להיות המחרוזת שהמשתמש סיפק בקלט הכלי.
      כלי 3 – שימוש בקלט מבוסס קבצים
   5. שוב, תסתכל על קובץ הכלים; כעת, במקום קלט מחרוזת, פרמטר הקלט משתמש בתג type="data", שמאפשר שימוש בקובץ. זה מוזכר בחלק הפקודות כנתיב קובץ, שוב באמצעות שם פרמטר הקלט.
   6. צור קובץ .txt באמצעות עורך טקסט מקומי, אם לא להריץ:
      'הד "שלום עולם מקובץ" > test_files/input.txt'
      מתיקיית השורש של המאגר כדי ליצור את קלט הדוגמה.
   7. העלה את קובץ .txt שנוצר כמו בשלב 2.1.1 ואז הרץ את Tool 3 כמו קודם, תוך בחירת קובץ .txt שהועלה כקלט. שוב, תסתכל על ה-stdout באותה צורה, ותוכן קובץ ה-.txt אמור להיות מוצג שם. אם משתמשים בפקודה למעלה, הפלט צריך להיות "hello world from a file".
      כלי 4 – כתיבת פלט לקובץ
   8. בדוק את galaxy-tools/simple/4/4.xml. כעת מדור פלט מכריז על קובץ פלט בשם שניתן להתייחס אליו בחלק הפקודות .
   9. הרץ את הכלי כרגיל עם קלט .txt , אך כעת במקום לראות את הפלט כמנהל, המשתמש הרגיל יכול לראות זאת בפאנל ההיסטוריה הזה, ובריצה מוצלחת, הכלי יהפוך לירוק וניתן יהיה להורדה/צפייה במנוע זרימת העבודה כפי שפורט בסעיפים הקודמים.
      כלי 5 – הרצת סקריפטים בכלים
   10. בדוק את galaxy-tools/simple/5/5.xml ואת הסקריפט המלווה בפייתון galcat-tools/simple/5/5.py. ב-XML, הפקודה מתייחסת לסקריפט Python מתוך תיקיית הכלים, וסעיף הדרישות מתייחס כעת לתמונה ב-Python כי Python נדרשת להרצת הסקריפט.
   11. פרוס והרץ את הכלי באותו אופן, והוא אמור להתנהג באותו אופן כמו כלי 4 (שלב 4.2.9), רק שהפעם הוא מריץ סקריפט במקום פקודה ישירות.
3. דוגמה לכלי מורכב
   הערה: סעיף זה מתעד את התפתחות כלי הנייטרוניקה כדוגמה מעובדת לדפוס המתואר בסעיף 4.1. הקבצים הרלוונטיים נמצאים ב-galaxy-tools/complex/openmc/. אותו דפוס מתכלל לכל סימולציה או קוד עיבוד.
   1. פתח את סקריפט הריצה לסימולציה. לדוגמה זו, סקריפט הרצה galgalaxy-tools/complex/openmc/openmc_run.py מנתח קובץ קונפיגורציה (openmc_config.json), כותב את קובץ הגדרות הנייטרוניקה, ומבצע את הסימולציה. בדוק את הסקריפט ישירות משורת הפקודה לפני שאתה אורז אותו בתמונה של Docker.
   2. בנה את סביבת ההרצה של Docker באמצעות קובץ Docker בכתובת galaxy-tools/complex/openmc/Dockerfile. זה מרחיב את התדמית הציבורית עם כמה חבילות נוספות. בנה ותייג אותו מקומית או הפנה אותו מרשם מכולות.
   3. צור את ה-XML wrapper galaxy-tools/complex/openmc/openmc.xml, והצהיר על תמונת Docker משלב 4.3.2 בסעיף הדרישות . הפקודה להריץ יחד עם קבצי הקלט והפלט (כמו בדוגמה בסעיף 4.2) צריכה להיות מוגדרת גם היא.
   4. פרוס את הכלי כפי שמופיע בשלבים 4.1.4-4.1.7 ואז השתמש בקלטי הבדיקה ששימשו בסעיף 2 כדי לוודא שהכלי פועל כראוי.
      הערה: הכלים הנותרים במופע (מסלולים h5 ל-vtp, CAD h5m ל-vtk, h5m ל-stl, stl ל-obj, vtp ל-obj, obj ל-USD) הם ממירים בפורמט קבצים העוקבים אחרי אותו דפוס פיתוח. קבצי ה-XML שלהם נמצאים בתיקיית galaxy-tools/complex/ ויכולים לשמש כדוגמאות נוספות.

5. חיבור תהליכי עבודה למטאברס

הערה: סעיף זה מספק חומר עזר למפתחים המתאר את אינטגרציית ה-API של מנוע זרימת העבודה ואת הארכיטקטורה של תוסף פלטפורמת המטאברס. משתמשים שצריכים להריץ זרימות עבודה רק מפלטפורמת המטאוורס צריכים לעקוב אחרי סעיף 3 ואינם חייבים לקרוא את הסעיף הזה. מפתחים המעוניינים לחבר אפליקציה קדמית אחרת למנוע זרימת העבודה צריכים להתחיל מסעיף 5.1.

1. Workflow Engine API
   הערה: Galaxy חושפת API של RESTful. ספריית Bioblend Python מספקת כיסוי ברמה גבוהה יותר סביב API זה ומהווה בסיס לכל סקריפטי העזרה המשמשים בפרוטוקול זה. Bioblend מותקן אוטומטית בתוך סביבות ההרצה הרלוונטיות של Docker המסופקות במאגר.
   1. ייבא Bioblend ויצר חיבור למנוע זרימת העבודה הפועל על ידי יצירת אובייקט GalaxyInstance עם כתובת השרת ומפתח ה-API משלב 1.5.2. בפייתון בסביבה שבה Bioblend מותקן:
      `מ-bioblend.galaxy ייבוא GalaxyInstance
      gi = GalaxyInstance(url='http://localhost:8080', key=)'
      הערה: זה יעבוד רק בפריסות מקומיות, אם מנוע זרימת העבודה מופעל על מכונה מרוחקת, החלף את ה-localhost בכתובת ובפורט של המופע המוגדרת.
   2. השתמש בפונקציות העזר ב-galaxy-api/helper_functs.py לביצוע פעולות נפוצות: רישום זרימות עבודה זמינות (get_workflows), שליפת הגדרות קלט לזרימות עבודה (get_inputs), והפעלת זרימת עבודה עם קבצי קלט מוגדרים (launch_workflow). עיין ב-docstrings הפנימיים בקובץ זה לחתימות פונקציות וסוגי תחזיות צפויות.
   3. הרחיב את helper_functs.py עם פונקציות נוספות לפי דרישת היישום. ה-API המלא ניתן למצוא בכתובת https://bioblend.readthedocs.io.
2. קישור זרימות עבודה למטאוורס
   הערה: סעיף זה מתאר רק את הארכיטקטורה של תוסף פלטפורמת המטאברס כדי שמפתחים יוכלו להתאים אותה לפלטי זרימת עבודה שונים, סוגי קבצים נוספים או פלטפורמות מטאברס חלופיות.
   1. פתח את נקודת הכניסה הראשית של ההרחבה ב-omni_exts/omni.galaxy.example/. הרחבה זו משתמשת בהרחבת הבסיס^{Omniverse 15} כנקודת התחלה. לאחר מכן הוא מוסיף את כל הפונקציונליות מקובץ API Python של פונקציות העזר שתואר בשלב 5.1.2 ומספק ממשק גרפי לאינטראקציה עם תהליכי העבודה.
   2. כאשר תהליכי עבודה מופעלים, הנתונים שהם מייצרים מורדים אוטומטית ממנוע זרימת העבודה ונשמרים מקומית, מה שמאפשר להמחיש אותם בפלטפורמת המטאברס. דבר זה גם מאפשר לשמור ולהפוך את המטא-דאטה שנוצרה במהלך תהליך העבודה לנגישה, ובכך לספק את מקור נתוני הסימולציה.
   3. מימוש זה משתמש בספריית omni.ui המקורית של Omniverse כדי לבנות את הממשק. הסיומת הראשית נמצאת בתיקיית ההרחבות, והיישום הראשי של הממשק נמצא בקובץ omni_exts/omni.galaxy.example/omni/galaxy/example/window.py .

תוצאות

אם הסימולציות מופעלות עם הקלטים המסופקים במאגר git, יש לקבל את התוצאות הבאות:

בהשלמה מוצלחת של שלב 2.1.3, גם נתוני ה-TBR וגם מערכי הנתונים של Tracks יופיעו בפאנל ההיסטוריה בירוק, מה שמעיד על ריצה מוצלחת. ערך TBR מייצג באמצעות קובץ הקונפיגורציה שסופק (5 אצווה של 1,000 חלקיקים) הוא בערך 0.76, עם שינויים בין ריצות של כ-±0.01. לכן, כל ערך שמתקבל עבור TBR בטווח של 0.74–0.78 צריך להיחשב כהצלחה. הטווח הרחב משקף את הא...

דיון

ישנם כמה שלבים קריטיים בתוך הפרוטוקול. רובם עוסקים בהגדרה הראשונית של מופע מנוע זרימת העבודה כגון: הוספת דואר המנהל (שלב פרוטוקול 1.2.2) כי זה נדרש לגישה של מנהל לכלים ולפאנלים של המשימות; יצירת מפתח ה-API בצורה נכונה עבור הרחבת פלטפורמת המטאוורס (שלב פרוטוקול 1.5.3) והדבקה נכונה לקובץ הערכים ברירת המחדל; וכאשר מוסיפים כלים, מוודאים שהם מתווספים לקובץ הקונפיגורציה של הכלי (שלב פרוטוקול 4.1.6) לפני אתחול מחדש, שכן הם נטענים בהפעלה, שגיאות כאן עשויות גם לא להיות ברורות ביומני זרימת העבודה....

חומרים

רשימת החומרים שנעשה בהם שימוש במאמר זה

שם	חברה	מספר קטלוג	הערות
Bioblend	Galaxy Project	v1.2+	ספריית Python המספקת מעטפת ברמה גבוהה סביב ממשק ה-REST של Galaxy. זה משמש בסקריפטים העזר של הרחבת Omniverse כדי לרשום זרימות עבודה, להשיג הגדרות קלט ולפתוח עבודות. מותקן אוטומטית בתוך תמונות ה-Docker הרלוונטיות; אין צורך בהתקנה במארח.
Docker Containers	Docker	v24.0.5	זמן ריצה למכולות המשמש לארז כל סימולציה וכלי עיבוד לאחר סימולציה עם כל התלותיים שלו, ומבטיח ניידות וניתנות לחזרה.
Galaxy	Galaxy Project	v22.05	מנוע זרימת עבודה קוד פתוח המשמש לתזמן את שרשור הסימולציה והכלים לעיבוד ולחשוף אותם דרך ממשק REST.
Git	Git SCM	v2+	נדרש כדי לשכפל את המאגר כדי לעקוב אחר הפרוטוקול
NVIDIA RTX GPU	NVIDIA	-	נדרש לעיבוד תלת-ממד בזמן אמת ב-Omniverse (סעיף 3). משתמשים ללא חומרת RTX יכולים להשלים את כל השלבים עד סעיף 2 ולהשתמש ב-ParaView לויזואליזציה (ראה דיון).
Omniverse	NVIDIA	Code 2022.3.3	הפלטפורמה התלת-ממדית השיתופית של NVIDIA. זה משמש כחזית הויזואליזציה והאינטראקציה לפלטים של זרימת העבודה דרך הרחבת Kit מותאמת אישית.
ParaView	Kitware	v5.11	יישום ויזואליזציה מדעית קוד פתוח המשמש כגיבוי ללא RTX לבדיקת פלטי.vtk/.vtp ביניים.
Protocol Repository	Custom	v1.0	מכיל את תצורת Galaxy יחד עם כל עטיפות ה-XML של הכלים, סקריפטים להפעלה, קובצי Dockerfiles, נתוני בדיקה וההרחבה של Omniverse. משובט בשלב 1.2.1. קבצים מרכזיים מסופקים גם כעליות משלימות ישירות (ראה I.2).
Python	Python	v3.10+	זמן ריצה הנדרש עבור סקריפט ההפעלה של OpenMC וסקריפטים העזר של הרחבת Omniverse. כלול בתוך תמונות ה-Docker הרלוונטיות או עם הורדת Omniverse; אין צורך בהתקנה נפרדת במארח.
The OpenMC Monte Carlo Code	OpenMC	v0.13.3	קוד פתוח של סימולציה של העברת חלקיקים Monte Carlo המשמש כאן לסימולציית ניטרונים של היתוך. זה מספק את יחס הריבוי של טריטיום (TBR) ופלטים של מעקב נויטרונים.
Windows Subsystem for Linux (WSL)	Microsoft	v2	נדרש כדי להריץ את Docker על מארחי Windows (התקן דרך `wsl --install` ב-powershell). משתמשי Linux ו-Mac אינם זקוקים לכך.