Holarch

התנהגות

דיאגרמות Action

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

אופן השימוש ←

בדף זה
  1. סקירה כללית
  2. מושגים
    1. הזרימה
    2. פריטים סביב הזרימה
  3. איך להשתמש בה
    1. מתי ולמה
    2. בניית זרימה מאפס
    3. בניית זרימה בגרירה מהלוח
    4. חיבור Input/Outputs ו-Resources
    5. הקצאת מבצעים
    6. פירוק וירידה לעומק
    7. סימולציה ותיקוף
    8. דוגמה מעשית: מעבר ההדמיה של CubeSat EO-1
    9. עצות ושיטות עבודה טובות
    10. טעויות נפוצות
    11. כיצד זה מתחבר לתכונות אחרות
  4. העורך
    1. כותרת הדף
    2. סרגל כלים
    3. סידור ▾
    4. יצירת דיאגרמת Asset
    5. לוח רכיבים
    6. מחוות על משטח העבודה
    7. מה כל צורה מציגה
    8. חלונית המאפיינים
  5. איך הדיאגרמה ממופה ל-LML
  6. סקריפטים של סימולציה
  7. מחיקה והסרה
  8. קיצורי מקלדת
  9. אפשרויות והגדרות
  10. הודעות
  11. מגבלות
  12. דפים קשורים

סקירה כללית

דיאגרמת Action מציגה איך Action הורה מתבצע. זו דיאגרמת ההתנהגות של LML, והסימולטור מריץ בדיוק את מה שהיא מציגה.

הדיאגרמה מציגה:

  • את ה-Actions הצאצאים, בסדר שבו הם רצים;
  • היכן הזרימה מתפצלת לנתיבים מקבילים או לחלופות, והיכן היא חוזרת בלולאה;
  • את ה-Input/Outputs (I/Os) שעוברים מ-Action אחד לאחר;
  • את ה-Resources שכל Action משתמש בהם;
  • את ה-Assets שמבצעים את העבודה.

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

אותה זרימה מניעה גם את Functional Flow Block Diagram (FFBD), את Activity Diagram של SysML ואת Timeline Diagram. עורכים את הזרימה בכל אחת מהן והאחרות עוקבות.

מושגים

הזרימה

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

רכיבמבנהמה זה אומרישות
Action (צעד טורי)תיבה כחולה מעוגלת עם מספר ושםצעד שמתחיל כשהרכיב הקודם מסתייםAction צאצא של השורש (decomposed by)
מקביליפס פיצול עם התווית parallel ופס סוגרשני ענפים או יותר שרצים באותו זמן. הזרימה ממשיכה כשכל הענפים מסתיימים.אין
SYNCבלוק שמסומן SYNC עם חוד בצד ימין, ופס סוגרענפים מקבילים עם ישות משלהם. ה-Duration שלה הוא פסק זמן שעוצר ענפים שלא הסתיימו.Action בשם "Sync Action" (סוג בקרה SYNC)
ORבלוק שמסומן OR עם חוד בצד שמאל, ועיגול סוגרהחלטה: ענף אחד בדיוק רץAction בשם "Or Action" (סוג בקרה OR)
LOOPעיגול כניסה, גוף הלולאה, בלוק שמסומן LOOP, חץ חזרה מקווקוהגוף חוזר על עצמו כל עוד תנאי ההמשך מתקיים. התנאי נבדק לפני כל מעבר.Action בשם "Loop Action" (סוג בקרה LOOP)
EXITתיבה אדומה שמסומנת EXITמסיים את ה-LOOP העוטף (או את הזרימה שהוא נמצא בה) כשמגיעים אליואין

ענף הוא נתיב אחד בתוך Parallel, SYNC או OR. כל ענף הוא רצף משלו ויכול להכיל כל רכיב, כולל מבנים נוספים. LOOP מכיל רצף אחד, שנקרא הגוף שלו.

OR, SYNC ו-LOOP הם מבנים עם ישות משלהם. הישות הזו היא צאצא של השורש כמו צעד, כך שהמבנה יכול לשאת שם, סקריפט ו(ב-SYNC) פסק זמן. מבנים אינם צעדים: הם אף פעם לא מופיעים כתיבות Action, ותצוגות כמו Timeline מדלגות עליהם.

פריטים סביב הזרימה

פריטמבנהקשרמשמעות
Input/Outputמקבילית מעל הזרימה. ירוקה כשהיא מפעילה Action, אפורה אחרת.Action generates I/O; Action receives I/Oמידע, נתונים או חומר שעוברים בין Actions
Input/Output של ההורהמקבילית עם התווית parent input (משמאל להתחלה) או parent output (מימין לסוף)ה-Action של השורש receives או generates אותההממשק של ה-Action ההורה. משורטט בקו מקווקו כל עוד אף Action צאצא לא משתמש בו.
Resourceמשושה סגול מתחת לזרימהAction consumes, produces או seizes Resource, עם Amountכמות ש-Actions מכלים, מחזירים או יוצרים
Asset מבצע⟂ ושם ה-Asset מתחת לשם ה-ActionAsset performs Actionמי או מה מבצע את ה-Action. מוצג כש-נכסים פעיל.
מבצע⟂ ושם ה-Asset על ענף Parallel או SYNCAsset performs כל Action בענףמבצע לענף שלם. נשמר מסונכרן בכל עריכה.

שני מונחים חשובים לסימולציה:

  • טריגר: I/O שמתקבל עם Trigger מוגדר (ברירת המחדל) גורם ל-Action המקבל לחכות עד שה-I/O קיים.
  • רשות: I/O שמתקבל עם Trigger כבוי. ה-Action מתחיל בלי לחכות לו.

קו של Resource מסומן בקשר ובכמות, למשל consumes 1.5. Resource שרק נתפס משורטט בהיר יותר.

איך להשתמש בה

מתי ולמה

בונים דיאגרמת Action ברגע שיש קבוצת פונקציות ולפני שמקצים אותן לארכיטקטורה הפיזית. הפונקציות מגיעות בדרך כלל מניתוח פונקציונלי של הדרישות.

הדיאגרמה עונה על השאלות האלה:

  • באיזה סדר הפונקציות רצות, ואילו רצות במקביל?
  • היכן המערכת מקבלת החלטה?
  • מה כל פונקציה צריכה ומה היא מפיקה?
  • כמה זמן לוקח כל הרצף?

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

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

בניית זרימה מאפס

יצירת הדיאגרמה:

  1. יש לפתוח את דיאגרמות בתחתית סרגל הניווט.
  2. יש ללחוץ על + דיאגרמה חדשה.
  3. תחת סוג הדיאגרמה יש לבחור דיאגרמת Action (בקבוצה התנהגות, עם התג LML).
  4. ב-שורש יש להקליד את שם ה-Action החדש, למשל Run Nominal Imaging Pass. (מספר כמו OPS אפשר לתת לו מאוחר יותר בחלונית המאפיינים.)
  5. יש ללחוץ על יצירה.

    מוצגים התחלה וסוף, והרמז יש לגרור לכאן רכיב או ללחוץ על + פעולה.

הוספת צעדים ברצף:

  1. יש ללחוץ על + הוספה ▾ → + פעולה ▾ → Action חדשה….
  2. יש להקליד את השם ב-הוספת פעולה.
  3. יש ללחוץ על אישור (או להקיש Enter).

    מוצגת תיבת Action ממוספרת בזרימה. המספרים ממשיכים מהמספר של ההורה: OPS.1, OPS.2 וכן הלאה. ה-Action החדש הוא צאצא של השורש.

  4. יש להשאיר את ה-Action החדש נבחר ולחזור על שלבים 1 עד 3 לצעד הבא. + פעולה תמיד מוסיף אחרי הרכיב שנבחר.

הוספת צעדים שרצים באותו זמן:

  1. יש לבחור את הצעד שאחריו מתחילים הצעדים המקבילים.
  2. יש ללחוץ על + הוספה ▾ → + סנכרון.

    מוצג SYNC עם שני ענפים ריקים.

  3. יש ללחוץ על קו ענף כדי לבחור אותו.
  4. יש ללחוץ על + הוספה ▾ → + פעולה ▾ → Action חדשה… כדי להוסיף צעד לענף הזה.
  5. יש ללחוץ על + ענף אם צריך ענף שלישי.

משתמשים ב-+ הוספה ▾ → + פעולה ▾ → ענפים מקבילים (בלי ישות) במקום + סנכרון כשלא צריך פסק זמן, שם או סקריפט.

הוספת החלטה:

  1. יש לבחור את הצעד שלפני ההחלטה.
  2. יש ללחוץ על + או.
  3. יש להזין את השאלה, למשל Contact in view?.

    מוצגים שני ענפים, כן ו-לא, 50% כל אחד.

  4. יש לבחור את ה-OR ולהגדיר את שמות התנאים ואת ההסתברויות בחלונית המאפיינים.

חזרה על צעד:

  1. יש לבחור את הצעד.
  2. יש ללחוץ על + הוספה ▾ → + לולאה.
  3. יש להזין את שם הלולאה.

    מוצג הצעד עטוף בלולאה שרצה פעמיים.

  4. את מספר האיטרציות, או תנאי אחר, מגדירים בחלונית המאפיינים.

הגדרת משכים ובדיקת התוצאה:

  1. יש לבחור Action.
  2. יש למלא את משך בקבוצה לוח זמנים של חלונית המאפיינים.
  3. כדי לתת לכמה Actions את אותו Duration, לוחצים עליהם עם Shift ומגדירים את משך (N Actions) בחלונית המאפיינים.
  4. יש ללחוץ על התג בדיקות הדיאגרמה בסרגל הכלים (✓ בדיקות, או ⚠ ומספר).

    חלונית המאפיינים מציגה את ה-Actions בלי Duration ואת הפריטים שלא מחוברים.

בניית זרימה בגרירה מהלוח

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

  1. יש לגרור Action לכל קו בזרימה. קו השחרור מודגש כשהפריט נמצא מעל מקום תקין.

    מוצג "New Action" בנקודה הזו. שדה השם שלו בחלונית המאפיינים נבחר, מוכן להקלדה.

  2. יש להקליד את השם.
  3. יש לגרור Parallel, או, סנכרון, לולאה או יציאה לקו באותו אופן.
  4. יש לגרור Input/Output אל Action. זה יוצר I/O שה-Action מפיק. שחרור על משטח ריק ממקם I/O לא מחובר.
  5. יש לגרור Resource אל Action. זה יוצר Resource שה-Action צורך (Amount 1). שחרור על משטח ריק ממקם אותו לא מחובר.
  6. יש לגרור מבצע לקו ענף של Parallel או SYNC, ואז לבחור את ה-Asset.

    ה-Asset מבצע עכשיו כל Action בענף הזה.

לשימוש חוזר בפריטים שכבר קיימים במודל:

  1. יש להקליד שם ב-הוספה או חיפוש…. בפרויקט מציג את ה-Actions, Input/Outputs, Resources ו-Assets התואמים.
  2. יש לגרור התאמה אל הדיאגרמה:
    • Action אל קו;
    • I/O או Resource אל Action או אל משטח העבודה;
    • Asset אל קו ענף של Parallel או SYNC.

במקלדת, מעבירים את המיקוד לפריט בלוח ומקישים Enter או Space. מבנים נוספים לסוף הזרימה הראשית. Input/Outputs ו-Resources נוספים למרכז התצוגה.

חיבור Input/Outputs ו-Resources

מחברים פריטים בגרירת ידית מצורה אחת לאחרת.

העברת I/O מ-Action אחד לאחר:

  1. יש לבחור את ה-Action הראשון.

    מוצגת ידית ירוקה מעליו.

  2. יש לגרור את הידית אל ה-Action השני.

    בזמן הריחוף, תיבת היעד מציגה שני חצאים.

  3. יש לשחרר על החצי Trigger (העליון) לקלט מפעיל, או על החצי Optional (התחתון) לקלט אופציונלי.

    Holarch יוצר Input/Output חדש. ה-Action הראשון מפיק אותו והשני מקבל אותו. ה-I/O החדש נבחר ושדה השם שלו מוכן להקלדה.

  4. יש להקליד את שם ה-I/O.

הידית של ה-Action יכולה גם להגיע למקומות אחרים:

  • אל Input/Output קיים: ה-Action מפיק אותו.
  • אל Resource: ה-Action מייצר אותו (Amount 1).
  • אל משטח ריק: Holarch יוצר פלט חדש של ה-Action.

גרימה ל-Action לקבל I/O קיים:

  1. יש לבחור את ה-Input/Output.
  2. יש לגרור את הידית שלו (מתחת לצורה) אל ה-Action.
  3. יש לשחרר על ה-Action, ואז לבחור Input (טריגר) או Input (אופציונלי) בבורר החיבור.

אם ה-Action כבר מקבל את ה-I/O הזה, רק הגדרת ה-Trigger שלו משתנה.

גרימה ל-Action להשתמש ב-Resource:

  1. יש לבחור את ה-Resource.
  2. יש לגרור את הידית שלו (מעל הצורה) אל ה-Action.
  3. יש לשחרר על החצי צורך (העליון) או על החצי תופס (התחתון).

מעבר בין consumes ל-seizes שומר על הכמות.

הגדרת הכמות של קישור משאב:

  1. יש לבחור את ה-Action.
  2. במקטע עקיבות בחלונית המאפיינים יש למצוא את ה-Resource תחת consumes, produces או seizes וללחוץ על מאפיינים.
  3. יש לערוך את מאפיין הקשר Amount.

מיקום ידני של I/Os ו-Resources:

  • יש לגרור צורת Input/Output או Resource למקום הרצוי. המיקום נשמר עם הדיאגרמה.
  • לחיצה על איפוס המיקום בחלונית המאפיינים שלה מחזירה אותה לפריסה האוטומטית מעל ה-Actions שמשתמשים בה או מתחתם.
  • יש לבחור סידור ▾ → איפוס מיקומי Input/Output ו-Resource כדי לאפס את כולם.

הקצאת מבצעים

הקצאת Asset ל-Action אחד:

  1. יש לבחור את ה-Action ולבחור פתיחה ב- ▾ → תצוגת פריט. (בדיאגרמה, performed by נעול בחלונית המאפיינים, כי הדיאגרמה מנהלת אותו.)
  2. במקטע עקיבות יש להוסיף performed by עם + → קישור פריט קיים….
  3. יש לבחור את ה-Asset.

הקצאת Asset לענף שלם של Parallel או SYNC, באחת משתי דרכים:

  • גוררים מבצע מחלונית ההוספה אל קו הענף.
  • בוחרים את ה-Parallel או ה-SYNC ולוחצים על + נכס ליד הענף בחלונית המאפיינים.

מפעילים את נכסים בסרגל הכלים כדי להציג את המבצעים מתחת לשם של כל Action.

פירוק וירידה לעומק

מתן זרימת צאצא משלו ל-Action אחד:

  1. יש לבחור את ה-Action.
  2. יש ללחוץ על פירוק.

    דיאגרמת ה-Action של ה-Action הזה נפתחת.

  3. בונים שם את זרימת הצאצא שלו.
  4. יש ללחוץ על ▲ הורה בכותרת הדף כדי לחזור.

אפשר גם לפתוח זרימת צאצא בלחיצה כפולה על Action מפורק או בלחיצה על סמל הפירוק שלו.

קיבוץ כמה צעדים ל-Action צאצא חדש:

  1. יש ללחוץ עם Shift על שני רכיבים או יותר שנמצאים זה ליד זה על אותו קו.
  2. יש ללחוץ על פירוק (קיבוץ).

    הרכיבים עוברים ל-Action צאצא חדש בשם "New Action" עם זרימה משלו. מוצגת ההודעה הקופצת קובץ ל-Action צאצא חדש. יש לתת לו שם בחלונית המאפיינים. ושדה השם נבחר.

  3. יש להקליד את השם החדש.

שיטוח זרימת צאצא חזרה לתוך הדיאגרמה הזו:

  1. יש לבחור Action מפורק.
  2. יש ללחוץ על שיטוח (בסרגל הכלים או בחלונית המאפיינים).

    זרימת הצאצא שלו מחליפה אותו בדיאגרמה הזו.

  3. יש לבחור שמירת ה-Action כדי להשאיר את ה-Action שהתרוקן במודל (מחוץ לדיאגרמה הזו), או מחיקת הפריט כדי למחוק אותו.

בסימולטור, Action מפורק מריץ את זרימת הצאצא שלו. ה-Duration שלו עצמו לא משמש.

סימולציה ותיקוף

  1. לפני ההרצה הראשונה פותחים את התג בדיקות הדיאגרמה ומתקנים את מה שהוא מציג.

    מוצג מה שהסימולטור יתייחס אליו כחסר:

    • Actions בלי Duration מדומים כ-0.
    • I/Os ששום Action לא מפיק משאירים את המקבלים שלהם בהמתנה (קיפאון).
    • Resources ששום דבר לא משתמש בהם מוצגים ברשימה.
  2. יש לתקן את מה שהבדיקה מדווחת.
  3. יש ללחוץ על ▶ סימולציה ▾ ולבחור אירוע בדיד כדי לצפות בהרצה מתוזמנת אחת, או מונטה קרלו להרצות רבות.

    הסימולטור נפתח עם ה-Action הזה כשורש.

  4. יש להריץ את הסימולציה.

הרצה שמחכה לנצח מדווחת כקיפאון. ה-סטטוס של הסימולטור מציג את הסיבה, והכרטיסייה יומן מציגה אותה:

  • ממתין ל-I/O … (אף פעם לא הופק)
  • ממתין ל-… (אף פעם לא זמין)

יש לתקן את הדיאגרמה ולהריץ שוב. לדוגמה, להפוך טריגר לקלט אופציונלי.

דוגמה מעשית: מעבר ההדמיה של CubeSat EO-1

פרויקט ההדגמה מכיל את דיאגרמת ה-Action OPS Run Nominal Imaging Pass.

  1. יש ליצור את פרויקט ההדגמה עם ניהול פרויקטים ← קובצי פרויקט ▾ ← פרויקט הדגמה חדש.
  2. יש לפתוח את הדיאגרמה מ-התנהגות → דיאגרמות Action.

הזרימה רצה כך:

  1. שלושה צעדים רצים ברצף:
    • OPS.1 Transmit Imaging Plan (Ground Station, משולשת 4–9 דקות, הערך הסביר ביותר 6);
    • OPS.2 Receive Imaging Plan (UHF Transceiver, דקה אחת);
    • OPS.3 Load Command Schedule (C&DH, 2 דקות).
  2. Parallel מריץ את OPS.4 Rotate to Target (ADCS, נורמלית 3 ± 0.5 דקות) ואת OPS.5 Prepare Camera (Payload Camera, 5 דקות) באותו זמן. שניהם מקבלים את Command Schedule כטריגר.
  3. LOOP בשם Each target מריץ את OPS.6 Capture Image Strip ואת OPS.7 Encode and Store Image ארבע פעמים (Continue (×4)).
  4. OR בשם Contact in view? בוחר את הצעד הבא:
    • Yes (75%): OPS.8 Transmit Image Data;
    • No (25%): OPS.9 Hold Data Onboard.
  5. Parallel אחרון טוען את הסוללה (OPS.10) בזמן שתחנת הקרקע מקבלת ומעבדת את הנתונים (OPS.11, OPS.12).

הזרימה משתמשת בשני Resources:

  • Battery Charge (Wh, התחלתי 62, מינימום 23, מקסימום 77). OPS.4 (1.5), OPS.5 (0.8), OPS.6 (2), OPS.7 (0.3) ו-OPS.8 (6) צורכים אותו. OPS.10 (30) מייצר אותו.
  • Data Storage (GB). OPS.7 (2.5) מייצר אותו ו-OPS.8 (8) צורך אותו.

Image Data Package הוא קלט אופציונלי של OPS.11. לכן מעבר בלי קשר לא גורם לקיפאון במקטע הקרקע.

אפשר לנסות את השינויים האלה:

  1. יש לבחור את ה-OR ולשנות את Yes ל-60 ואת No ל-40.

    בתוויות הענפים כתוב Yes (60%) ו-No (40%). חלונית המאפיינים מציגה סה״כ 100%.

  2. יש לבחור את ה-LOOP ולהגדיר את מספר איטרציות ל-6.

    בטקסט הלולאה כתוב Continue (×6).

  3. יש לבחור ▶ סימולציה ▾ → מונטה קרלו ולהריץ.

    יותר מטרות בכל מעבר צורכות יותר סוללה. רצועת הסיכום והכרטיסייה התפלגות מציגות את זמן המעבר הארוך יותר.

  4. יש להפעיל את נכסים כדי לראות כל מבצע.
  5. יש לבחור סידור ▾ → יצירת דיאגרמת Asset.

    Holarch יוצר את ה-Asset "Run Nominal Imaging Pass performers". הצאצאים שלו הם ה-Assets המבצעים, עם Conduits לכל I/O שעובר בין שניים מהם. דיאגרמת ה-Asset שלו נפתחת.

עצות ושיטות עבודה טובות

  • נותנים ל-Actions שמות של פועל + מושא (Capture Image Strip) ול-I/Os שמות עצם (Image Strip). נותנים לתנאי OR שמות שהם תשובות לשאלה של ה-OR.
  • שומרים כל דיאגרמה על כשבעה עד שנים-עשר רכיבים. מקבצים פירוט ל-Actions צאצאים עם פירוק (קיבוץ).
  • כברירת מחדל משתמשים ב-Parallel (בלי ישות). משתמשים ב-SYNC רק כשצריך פסק זמן, שם או סקריפט.
  • OR במצב הסתברות חייב להסתכם ב-100%. כשההסתברויות לא ידועות, בוחרים ללא (שאלה במהלך ההרצה, או אקראי). הסימולטור שואל אז, או שמונטה קרלו משתמש בהסתברויות שוות.
  • נותנים Duration לכל Action עלה לפני הסימולציה. כשהזמן משתנה, משתמשים בהתפלגות, למשל =norm.dist(40,6) Seconds.
  • הופכים I/O שמתקבל ל-רשות כשה-Action יכול להתחיל בלעדיו. אחרת ענף שאף פעם לא מפיק אותו גורם לקיפאון בהרצה.
  • ממספרים צאצאים לפי סדר הזרימה עם מספור מחדש של הצאצאים… בחלונית המאפיינים של השורש (סידור ▾ → הגדרות הדיאגרמה), כשסדר הצאצאים מוגדר לסדר הזרימה.

טעויות נפוצות

תסמיןסיבהתיקון
יש לשחרר את המבנה על קו זרימה.מבנה או Action שוחררו על צורה או על משטח ריקיש לשחרר אותו על חץ בין רכיבים
הסתברויות הענפים מסתכמות ב-90 %. יש לשנות אותן כך שיסתכמו ב-100 %.ההסתברויות של OR לא מסתכמותיש לתקן את האחוזים, או להוסיף ענף
הסימולציה אף פעם לא מסתיימת (קיפאון)Action מחכה ל-I/O מפעיל ששום דבר לא מפיק בנתיב הזהיש להפוך את הקלט ל-רשות, או להפיק אותו בכל נתיב
Action לא לוקח זמן בסימולציהאין Duration, או שה-Action מפורק (זרימת הצאצא שלו רצה במקומו)יש להגדיר את ה-Duration שלו, או להוסיף משכים לצאצאים שלו
צעד נראה כאילו נעלםהוא הוסר מהדיאגרמה אבל נשמר במודליש להקליד את השם שלו ב-הוספה או חיפוש… ולגרור אותו בחזרה לקו
יצירת דיאגרמת Asset מדווחת לאף Action כאן אין מבצע…לאף Action אין Asset ב-performed by ולאף ענף אין מבצעיש להקצות קודם מבצעים

כיצד זה מתחבר לתכונות אחרות

  • מקבל נתונים מ: ניתוח פונקציונלי יוצר את הפונקציות (Actions צאצאים) ואת הזרימה שלהן. דרישות מגיעות ל-Actions דרך satisfied by. Assets ו-Resources באים מהארכיטקטורה.
  • מזין את הסימולטור: זמן, עלות, רמות משאבים, ניצולת Assets ובדיקות דרישות. ראו סימולציה.
  • מזין תצוגות אחרות של אותה זרימה: ה-FFBD ו-Activity Diagram.
  • מזין תצוגות נגזרות:
    • Timeline Diagram (לוח זמנים מ-Start ו-Duration);
    • Sequence Diagram (קווי החיים הם ה-Assets המבצעים, ההודעות הן ה-I/Os);
    • יצירת דיאגרמת Asset (הקשר פיזי ו-Conduits);
    • N² Diagram (I/Os בין פונקציות);
    • IDEF0 (כניסות ויציאות).
  • עקיבות: המקטע עקיבות בחלונית המאפיינים מציג את הדרישות של כל Action (satisfies). ה-RVTM ומטריצת העקיבות קוראים את אותם קשרים.

העורך

דיאגרמת ה-Action משתמשת בעורך הדיאגרמות המשותף (ראו דיאגרמות). יש בה שורת סרגל כלים, הלוח בצד ימין, משטח העבודה, וחלונית המאפיינים בצד שמאל.

  • בורר סוג הדיאגרמה: מציג את אותו Action שורש בסוג דיאגרמה אחר שחל על Actions. הסוגים הם Hierarchy, Spider, Tree, Risk, Timeline, Action, Sequence, Use Case, N2, IDEF0, ICOM (A0), Activity ו-FFBD.
  • ▲ הורה: פותח את דיאגרמת ה-Action של ה-Action ההורה. מוצג רק כשלשורש יש Action הורה.

סרגל כלים

סרגל הכלים הוא שורה אחת של קבוצות. פעולות ההוספה של קבוצת ההוספה (+ פעולה ▾, + סנכרון, + או, + לולאה, + יציאה, + ענף, + I/O) נמצאות ברשימה אחת + הוספה ▾: הן פועלות בבחירה (אחריה, סביבה, על הענפים שלה), בעוד שהחלונית הוספה בצד ימין מוסיפה בגרירה או ב-Enter. ברשימה, ↓ ו-↑ עוברים בין פעולות ההוספה ו-Esc סוגר אותה. כשהחלון צר, פריטים עוברים אל ⋯ (פעולות נוספות); + הוספה ▾ נשאר בשורה, ורק פירוק ו-▶ סימולציה ▾ נשארים בצורה המלאה. בחירת צורה פותחת את חלונית המאפיינים בלי להזיז את הכפתורים של סרגל הכלים.

קבוצהפקדמה הוא עושה
מצבהזזהגוררים את הרקע כדי להזיז את התצוגה (ברירת המחדל).
מצבבחירה במלבןבוחר רק הערות בדיאגרמות Action. רכיבי זרימה בוחרים עם Shift-לחיצה.
הוספה+ הוספה ▾פותח את רשימת פעולות ההוספה שלהלן ("הוספה בבחירה").
הוספה+ פעולה ▾Action חדשה… מבקש את השם (ברירת מחדל New Action). Action קיימת… בוחר Action שאינו השורש, אחד מהאבות שלו, או כזה שכבר נמצא בדיאגרמה הזו. ענפים מקבילים (בלי ישות) מוסיף ענפים מקבילים. ההוספה היא אחרי הבחירה, בסוף ענף שנבחר, או בסוף הזרימה.
הוספה+ סנכרוןמוסיף SYNC עם שני ענפים ריקים.
הוספה+ אומבקש את שם ההחלטה (שאלה) (ברירת מחדל Or Action), ואז מוסיף OR עם הענפים Yes ו-No ב-50%.
הוספה+ לולאהמבקש את שם הלולאה (תנאי החזרה) (ברירת מחדל Loop Action). כשרכיב נבחר, הוא עוטף את הרכיב בלולאה (הכנסת הרכיב שנבחר לתוך LOOP). אחרת הוא מוסיף לולאה ריקה (הוספת LOOP ריקה). לולאות חדשות רצות 2 איטרציות.
הוספה+ יציאהמוסיף EXIT אחרי הבחירה.
הוספה+ ענףמוסיף ענף ל-Parallel, SYNC או OR שנבחרו (או לזה שהענף שלו נבחר). ההסתברויות של OR מחולקות מחדש באופן שווה. מושבת אחרת.
הוספה+ I/Oכש-Action נבחר, בוחרים את ה-Action המקבל (Input/Output מ-"…" אל…), ואז נותנים שם ל-I/O החדש. ה-Action הראשון מפיק אותו והשני מקבל אותו כטריגר.
עריכהביטול פעולה, ביצוע חוזר⌘Z / Ctrl+Z, ⇧⌘Z / Ctrl+Shift+Z.
עריכהחיבור…מחבר את הצורה שנבחרה לצורה אחרת מהמקלדת, עם אותן אפשרויות כמו בגרירת הידית שלה (ראו מקלדת וקוראי מסך).
עריכה◀, ▶הזזת הרכיב שנבחר מקום אחד שמאלה או ימינה בתוך הרצף שלו.
עריכההסרההסרת הבחירה מהדיאגרמה; Shift+לחיצה מוחקת את הישויות (ראו מחיקה והסרה).
View−, אחוז הגדלה, +, ⤢הקטנה, הקלדת רמת הגדלה (10–400%), הגדלה, התאמת הדיאגרמה.
Viewחיפוש בדיאגרמה עם ‹ ›מדגיש Actions, I/Os ו-Resources שהשם, המספר, התיאור, המזהה או ערכי המאפיינים שלהם תואמים. ↓ / ↑ (או ‹ ›) עוברים בין התאמות; Enter בוחר את הנוכחית.
Viewתוכןתוכן הדיאגרמה: הצורות, החיבורים והקשרים כטקסט.
Viewהגדרהמציג את השורש ואת סוג הדיאגרמה בחלונית המאפיינים, כדי להחליף כל אחד מהם במקום (ראו הגדרה: שורש וסוג).
Viewסידור ▾ראו סידור ▾ להלן.
Viewהתג בדיקות הדיאגרמהיתומים ומעגלים ועוד הבדיקות של דיאגרמת Action (ראו הודעות), מוצגים בחלונית המאפיינים עם הצגה.
ViewI/O, Resources, נכסים, I/O של ההורההצגה או הסתרה של Input/Outputs, Resources, Assets מבצעים ו-Input/Outputs של ההורה. הבחירה נשמרת עם הדיאגרמה והופכת לברירת המחדל לדיאגרמות Action חדשות.
פעולות סוגפירוק / פירוק (קיבוץ)Action אחד נבחר: פתיחת דיאגרמת ה-Action של הצאצא שלו. כמה רכיבים: קיבוץ שלהם ל-Action צאצא חדש.
פעולות סוגשיטוחהחלפת ה-Action המפורק שנבחר בזרימת הצאצא שלו.
פעולות סוגפתיחהפותח את תצוגת הפריט של הישות שנבחרה, או של השורש.
פעולות סוג▶ סימולציה ▾אירוע בדיד או מונטה קרלו: פותח את הסימולטור עם השורש הזה.
פלטייצוא…דיאגרמה (PNG) עם רקע שקוף וקנה מידה, דיאגרמה (SVG), דיאגרמה (HTML), דיאגרמה (Word), דיאגרמה (הדפסה).
עוד⋯פריטים שגלשו, ואחריהם פתיחת תצוגת הפריט, כל הדיאגרמות, עזרה לדיאגרמת Action ו-מחיקת הדיאגרמה….

סידור ▾

פריטמה הוא עושה
שחזור ברירות המחדלמנקה מיקומים ידניים של I/O ו-Resource.
הצגה / הסתרההסתרת Resources, הסתרת כל ה-Input/Outputs, הסתרת Input/Outputs של ההורה, הסתרת Assets מבצעים ו-הסתרת הלוח; כל פריט מציג הצגת … כשהחלק הזה מוסתר (למשל הצגת Assets מבצעים).
איפוס מיקומי Input/Output ו-Resourceמחזיר כל I/O ו-Resource שהוזזו לפריסה האוטומטית.
יצירת דיאגרמת Assetיוצר "root performers", ראו יצירת דיאגרמת Asset.
פתיחה כ-FFBDפותח את אותה זרימה כ-Functional Flow Block Diagram.
הגדרות הדיאגרמההשורש בחלונית המאפיינים עם מספור מחדש של הצאצאים… (מספרים ישנים → חדשים; סדר הצאצאים, מתאר או זרימה, בא מ-העדפות הפרויקט → מספור; ביטול פעולה אחד מחזיר הכול לאחור).
הסתרת חלונית ההוספה / הצגת חלונית ההוספהמסתיר את הסרגל הצדדי הימני (לוח והערות) בכל דיאגרמה.

יצירת דיאגרמת Asset

סידור ▾ → יצירת דיאגרמת Asset בונה את ההקשר הפיזי של הזרימה מהמבצעים שלה.

  • הוא יוצר את ה-Asset "root performers". ה-Asset הזה מבצע את ה-Action של השורש.
  • ה-Asset החדש הוא decomposed by כל Asset מבצע. המבצעים באים מ-performed by וממבצעי ענפים, בכל הרמות שמתחת לשורש.
  • לכל זוג Assets שה-Actions שלהם מחליפים I/O, הוא משתמש שוב ב-Conduit או יוצר אחד. ה-Conduit נקרא "A to B", או "A / B" כשה-I/O עובר בשני הכיוונים, והוא transfers את ה-I/Os האלה.
  • אחר כך הוא פותח את דיאגרמת ה-Asset.

לוח רכיבים

החלונית הוספה (הרמז יש לגרור לקו או לצורה, או להקיש Enter) מציגה:

פריטשחרור עליוצר
פעולהקוAction חדש "New Action"
מקביליקוענפים מקבילים (בלי ישות)
אוקוישות Action מסוג OR עם הענפים Yes/No
סנכרוןקוישות Action מסוג SYNC
לולאהקוישות Action מסוג LOOP (גוף ריק, 2 איטרציות)
יציאהקוEXIT
Input/OutputAction, או כל מקוםI/O חדש בשם "I/O", שה-Action מפיק כשמשחררים אותו עליו
ResourceAction, או כל מקוםResource חדש בשם "Resource", שנצרך (Amount 1) כשמשחררים אותו על Action
מבצעקו ענף של Parallel או SYNCמבקש את ה-Asset (המבצע של ענף זה), שמבצע אז את הענף

מקלידים שם ב-הוספה או חיפוש…: יצירה מציע "name" בתור Action, Or, Sync, Loop, Input/Output או Resource, ו-בפרויקט מציג Actions, Input/Outputs, Resources ו-Assets תואמים (עד 60; לא השורש ולא ישויות מבנה). גוררים שורה פנימה, או מקישים Enter עליה.

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

מחוות על משטח העבודה

מחווהתוצאה
לחיצה על צורהבחירה שלו; חלונית המאפיינים מציגה אותו
Shift+לחיצההוספה או הסרה של רכיב מהבחירה
לחיצה על קובחירת הענף שהוא שייך אליו (או ניקוי הבחירה בקו הראשי)
לחיצה על הרקעניקוי הבחירה
גרירת Action או מבנה לקוהזזה שלו לשם (עם כל מה שבתוכו)
גרירת I/O או Resourceמיקום חופשי שלו
גרירת הידית הירוקהחיבור (ראו חיבור Input/Outputs ו-Resources)
לחיצה כפולה על Actionפתיחת דיאגרמת ה-Action של הצאצא שלו כשהוא מפורק, אחרת תצוגת הפריט שלו
לחיצה כפולה על I/O או Resourceפתיחת תצוגת הפריט שלו
לחיצה על סמל הפירוקפתיחת דיאגרמת ה-Action של הצאצא
גרירת הרקעהזזה
גלילה / ⌘ / Ctrl+גלילההזזה / הגדלה במיקום הסמן

מה כל צורה מציגה

  • תיבת Action: המספר (למעלה), השם, ושורה אחת מתחת. השורה הזו מציגה את ה-Duration (למשל 1 minute), או את ה-Assets המבצעים כש-נכסים פעיל.
  • { } בסגול בפינה השמאלית התחתונה: ל-Action או למבנה יש סקריפט סימולציה.
  • סמל פירוק בפינה הימנית העליונה: ל-Action יש זרימת צאצא משלו. לחיצה על הסמל פותחת אותה.
  • תוויות ענפי OR: שם התנאי וההסתברות שלו (Yes (75%)) או התנאי (Low [< 20], [else]).
  • תוויות ענפי Parallel ו-SYNC: שם הענף והמבצע שלו.
  • טקסט הלולאה מתחת לחץ החזרה: Continue (×4), Continue (50%), Continue while Battery Charge > 20, Continue (script) או Continue (ask). Exit מסמן את הדרך החוצה.
  • שם המבנה: מוצג בנטוי ליד בלוקים של OR, SYNC ו-LOOP.

חלונית המאפיינים

חלונית המאפיינים בצד שמאל מציגה את הבחירה. מה שהיא מציגה תלוי במה שבוחרים.

Action, Input/Output, Resource או Asset: חלונית הישות המשותפת. יש בה:

  • הכותרת עם המחלקה, המספר והשם, ו-פתיחה ב- ▾ (תצוגת פריט וכל דיאגרמה אחרת של הישות הזו);
  • הגדרה: מספר, שם ו-תיאור;
  • צורה: הפעולות הנוספות שבטבלה שלהלן, ו-מיקום וגודל;
  • קבוצות המאפיינים (Workflow, לוח זמנים וכן הלאה), ואחריהן עקיבות, דיון ו-פרטים.

הקשרים שהדיאגרמה הזו מנהלת נעולים במקטע העקיבות, כך שהדיאגרמה והמודל נשארים מסונכרנים. הם consumed by, decomposed by, generated by, performed by, produced by, received by ו-seized by.

בחירהפעולות נוספות
פעולהדיאגרמת Action, עריכת הסקריפט…, שיטוח (כשמפורק), הסרה ו-מחיקת הפריט…
Input/Output או Resource שהוזזואיפוס המיקום
I/O של ההורה שמפורק ל-I/Os צאצאיםהצגת Input/Outputs של ההורה מציג את הצאצאים שלו במקומו; הסתרת Input/Outputs של ההורה מחזיר
כל אחדהסרה ו-מחיקת הפריט…

OR נבחר (החלונית OR (החלטה)):

  • שם ההחלטה: השם של ישות ה-OR.
  • סוג ההחלטה: הסתברות, כמות ה-Resource, סקריפט או ללא (שאלה במהלך ההרצה, או אקראי).
  • Resource (רק בכמות ה-Resource): ה-Resource שהכמות שלו מושווית.
  • ענפים: שם תנאי לכל ענף. לפי הסוג, לכל ענף יש גם הסתברות (0–100 %), או אופרטור (==, !=, >, <, >=, <=, else) וערך.
  • שורת הסכום: כתוב בה סה״כ 100%, או האזהרה הסתברויות הענפים מסתכמות ב-N %. יש לשנות אותן כך שיסתכמו ב-100 %.
  • עריכת הסקריפט…/הוספת סקריפט… (הסוג סקריפט): onEnd() מחזירה את שם התנאי של הענף שיש לקחת.
  • הערה לסוג ללא: בהחלטות "Prompt" הסימולטור שואל איזה נתיב לקחת; כשההרצה אוטומטית הוא בוחר ענף באקראי.
  • + הוספת ענף, פתיחת הפריט.

SYNC נבחר:

  • שם.
  • מגבלת זמן: אופציונלי. אחרי הזמן הזה ה-SYNC מסתיים ועוצר את הענפים שעדיין רצים.
  • ההערה N ענפים רצים במקביל; הזרימה ממשיכה כשכולם מסתיימים.
  • שורה אחת לכל ענף: שם הענף ו-+ נכס. אחרי שהוגדר Asset, השורה מציגה ⟂ שם ה-Asset ו-× להסרתו.
  • עריכת הסקריפט…/הוספת סקריפט…, + הוספת ענף, פתיחת הפריט.

Parallel נבחר: כמו SYNC, בלי שדות הישות.

ענף נבחר: ענף N נבחר — + פעולה מוסיף אליו.

LOOP נבחר:

  • שם (תנאי).
  • חזרה כל עוד: איטרציות, הסתברות, כמות ה-Resource, סקריפט או ללא (שאלה במהלך ההרצה, או אקראי).
  • לפי התנאי: מספר איטרציות (מינימום 1), הסתברות להמשך (%), או Resource ועוד המשך כל עוד הכמות עם אופרטור וערך.
  • הערה לסקריפט: לפני כל מעבר נקראת onEnd(); החזרת true מריצה את הגוף שוב.
  • הערה לסוג ללא: בהחלטות "Prompt" הסימולטור שואל על מספר האיטרציות; כשההרצה אוטומטית הוא מריץ 0–2 מעברים באקראי.
  • עריכת הסקריפט…/הוספת סקריפט…, ההערה EXIT בגוף הלולאה עוצר את הלולאה מוקדם., פתיחת הפריט.

EXIT נבחר: עוצר את ה-LOOP העוטף, או את הזרימה הזו, כשמגיעים אליו.

כמה רכיבים נבחרו: N רכיבים נבחרו, משך (N Actions) (שדה חי: שינוי מגדיר את ה-Duration בכל Action שנבחר כצעד ביטול אחד; הוא נשאר ריק כשהמשכים שלהם שונים), פירוק (קיבוץ ל-Action צאצא חדשה) ו-הסרה.

איך הדיאגרמה ממופה ל-LML

על הדיאגרמהבמודל
השורש של הדיאגרמהה-Action ההורה
תיבת ActionAction צאצא: הורה decomposed by צאצא
בלוק OR, SYNC, LOOPAction צאצא עם סוג בקרה, decomposed by ההורה
סדר, ענפים, לולאותמבנה הזרימה שנשמר עם ההורה (הסדר שבו הצאצאים רצים)
קו מ-Action אל I/OAction generates Input/Output
קו מ-I/O אל ActionAction receives Input/Output, עם מאפיין הקשר Trigger (Yes = טריגר, No = אופציונלי)
קו בין Action ל-Resourceconsumes, produces או seizes, כל אחד עם המאפיין Amount
⟂ AssetAsset performs Action (ההפוך performed by). מאפיין הקשר Amount הוא מספר היחידות של ה-Asset הזה שה-Action תופס.
Duration על תיבההמאפיין Duration של ה-Action (מספר או התפלגות, עם יחידה)
זרימת צאצאדיאגרמת ה-Action של ה-Action הצאצא עצמו

המאפיינים של המחלקות בדיאגרמה הזו:

  • Action: Start (תאריך ושעה), Duration (ערך או התפלגות ועוד Seconds, Minutes, Hours, Days, Weeks, Months או Years) ו-Percent Complete.
  • Resource: Units, Initial Amount, Minimum Amount ו-Maximum Amount.
  • Input/Output: Size, Units, Type ו-Value.

סקריפטים של סימולציה

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

כדי לערוך סקריפט:

  1. יש לבחור Action, OR, SYNC או LOOP.
  2. יש ללחוץ על עריכת הסקריפט… (Action) או על עריכת הסקריפט…/הוספת סקריפט… (OR, SYNC, LOOP).
  3. יש ללחוץ על הוספת onStart(), הוספת prompt(), הוספת onEnd() או הוספת duration() כדי להכניס פונקציית hook ריקה.
  4. יש לכתוב את הקוד. Tab מכניס שני רווחים.
  5. יש ללחוץ על שמירה. סקריפט ריק מסיר את הסקריפט.

ה-hooks:

  • onStart() רצה כשהרכיב מתחיל.
  • prompt(p) בונה שאלה למשתמש: p.setTitle(), p.addEnumInput(title, name, choices, default), addTextInput, addNumberInput, addBooleanInput.
  • onEnd(response) רצה בסוף. OR מחזיר את שם הענף שיש לקחת. LOOP מחזירה true כדי להריץ את הגוף שוב.
  • duration() מחזירה את המשך של ה-Action כשה-Duration שלו הוא =script().

סקריפטים יכולים לקרוא ל:

  • Sim.getEntityByName(n), Sim.getAmount(name), Sim.setResourceByName(name, v);
  • Sim.getCurrentTime(), Sim.getCurrentCost();
  • print(x);
  • globals.put(k, v) / globals.get(k).

משתנים ברמה העליונה נשמרים לאורך ההרצה. Math.random משתמש במחולל עם הזרע של ההרצה. ה-API המלא, ארגז החול ובקשת האמון מופיעים בסימולציה.

מחיקה והסרה

Delete או הסרה מוציאים את הבחירה מהדיאגרמה מיד ושומרים את הישויות; ההערה הוסר מהדיאגרמה. מציעה ביטול פעולה ו-מחיקת הפריט…. ⇧Delete / Shift+Delete או מחיקת הפריט… שואלים קודם, ואז מוחקים גם את הישויות. ביטול פעולה אחד מבטל כל אחת מהן (ראו הסרה ומחיקה).

בחירההסרה מוציאה מהדיאגרמה⇧Delete / Shift+Delete מוחק גם
Action, OR, SYNC או LOOPאת הרכיב ואת הרכיבים שבתוכואת הישות של הרכיב
Parallel או EXITאת המבנה ואת הרכיבים שבתוכואת הישויות שבתוכו
ענףאת הענף ואת הרכיבים שלו; הענף האחרון, או גוף לולאה, מסירים את כל המבנהאת הישויות שבענף
כמה רכיביםאת כל הרכיבים שנבחרואת הישויות שלהם
Input/Output, Resource או Assetאת הקישורים שלו ל-Actions שמוצגים כאןאת הישות
מבצע (× בחלונית המאפיינים)הסרת המבצע: "name" מבצע N Actions בענף הזה. להסיר גם את קשרי ה-performed by האלה?שמירת הקשרים, הסרת הקשרים

הסרה מסיר גם את קישור ה-decomposed by של ה-Action לשורש, כך שהוא כבר לא צאצא. הישות והקשרים האחרים שלה נשארים.

קיצורי מקלדת

מקשפעולה
Delete או Backspaceהסרת הבחירה מהדיאגרמה (הישויות נשארות)
⇧Delete / Shift+Deleteמחיקת הישויות שנבחרו מהפרויקט, אחרי אישור
Escניקוי הבחירה
Shift+לחיצההוספה לבחירה או הסרה ממנה
⌘Z / Ctrl+Z / ⇧⌘Z / Ctrl+Shift+Zביטול פעולה / ביצוע חוזר
Enter או Space על פריט בלוחהכנסה שלו (מבנים בסוף הזרימה הראשית, I/Os ו-Resources במרכז)
⌘ / Ctrl+גלילהזום
Enter בשדה הזוםהחלת רמת ההגדלה שהוקלדה
↓ / ↑ בחיפוש בדיאגרמהההתאמה הבאה / הקודמת; Enter בוחר אותה, Esc מנקה את החיפוש

אפשרויות והגדרות

  • הצגה/הסתרה (מתגים בסרגל הכלים ו-סידור ▾): I/O, Resources, נכסים, I/O של ההורה ולוח. נשמר לכל דיאגרמה, ונזכר בדפדפן הזה כברירת המחדל לדיאגרמות Action חדשות. ברירות מחדל: I/O, Resources, I/O של ההורה ולוח פעילים; נכסים כבוי.
  • מיקומי I/O ו-Resource: נשמרים לכל דיאגרמה. מאפסים אותם עם איפוס המיקום או איפוס מיקומי Input/Output ו-Resource.
  • הגדלה ומיקום: נשמרים לכל דיאגרמה. דיאגרמה נפתחת מותאמת לחלון, אבל לא פחות מ-70%.
  • תצוגה לקריאה בלבד: אנשים בתפקיד צופה רואים את הדיאגרמה בלי קבוצות העריכה של סרגל הכלים, הלוח, הידיות או חלונית הבחירה. הם יכולים להזיז, להגדיל, לחפש ולייצא.

הודעות

הודעהמשמעות
יש לשחרר את המבנה על קו זרימה.אפשר להכניס מבנים ו-Actions רק על חץ.
רכיב לא יכול להיכנס לתוך עצמו. יש לשחרר אותו בחוץ.שחררת מבנה בתוך ענף שלו עצמו, או ניסית להוסיף את השורש או אחד מהאבות שלו.
"name" כבר נמצא בדיאגרמה הזו.ה-Action הזה כבר נמצא בזרימה.
יש לבחור Parallel, SYNC או OR כדי להוסיף ענף+ ענף דורש שאחד מהם (או אחד מהענפים שלו) ייבחר.
יש לבחור קודם את ה-Action שמפיק את ה-Input/Output+ I/O דורש Action שנבחר.
יש לבחור Action לפירוק, או ללחוץ עם Shift על כמה כדי לקבץ אותםפירוק דורש Action (לא מבנה).
אי אפשר לקבץ: הרכיבים נמצאים בענפים שונים. יש לבחור רכיבים ברצף אחד.הרכיבים המקובצים חייבים להיות באותו רצף.
אי אפשר לקבץ: הרכיבים לא סמוכים. יש לבחור רכיבים שבאים זה אחרי זה.הרכיבים המקובצים חייבים להיות רצופים.
קובץ ל-Action צאצא חדש. יש לתת לו שם בחלונית המאפיינים.פירוק (קיבוץ) הצליח.
יש לבחור Action עם דיאגרמת צאצא לשיטוחשיטוח דורש Action עם זרימת צאצא.
דיאגרמת הצאצא ריקה. יש להוסיף לה Actions לפני השיטוח.ל-Action הצאצא אין צאצאים.
אי אפשר לשטח: זרימת הבקרה של הצאצא פגומה.זרימת הצאצא מפנה לישויות שנמחקו; יש לפתוח אותה כדי לתקן אותה.
אי אפשר לשטח את הקבוצה הזו: אחד הצאצאים שלה כבר מופיע ברמה הזו.השיטוח היה מציב Action פעמיים.
מספר האיטרציות חייב להיות 1 או יותר. יש להזין מספר שלם של 1 לפחות.מספר איטרציות מתחת ל-1 נדחה.
הסתברויות הענפים מסתכמות ב-N %. יש לשנות אותן כך שיסתכמו ב-100 %.יש לתקן את ההסתברויות של ה-OR.
"name" מבצע עכשיו את ה-Actions בענף הזה.הוגדר מבצע.
לאף Action כאן אין מבצע. יש לקשר Actions ל-Assets (performed by), או לשחרר מבצע על ענף.ליצירת דיאגרמת Asset אין מה למקם.
נוצר "name performers" עם N Assets ו-M Conduits.יצירת דיאגרמת Asset הצליחה.
יש לגרור לכאן רכיב או ללחוץ על + פעולההזרימה ריקה.
ה-Action הזה נמחק.השורש נמחק.
✓ בדיקות בתג בדיקות הדיאגרמההבדיקות לא מצאו דבר.
… אין לו קשר לשום דבר אחר בדיאגרמה הזו. … יש לחבר אותו או להסיר אותו.ממצא של בדיקות הדיאגרמה (יתומים ומעגלים), עם הסיבה: אף Action בדיאגרמה הזו לא מפיק או מקבל את Input/Output "name"., אף Action בדיאגרמה הזו לא צורך, מייצר או תופס את Resource "name". או ל-Action "name" אין Duration (מדומה כ-0).
הפירוק רץ במעגל: … יש להסיר אחד מקשרי ה-decomposed by האלה.Action הוא (בעקיפין) הצאצא של עצמו.
צפייה בלבד: יש לבקש מבעלים הרשאת עריכה.התפקיד שלך בפרויקט הזה הוא צופה.

מגבלות

  • זרימה אחת לכל Action הורה.
  • Action יכול להופיע רק פעם אחת בזרימה נתונה. כדי לחזור עליו משתמשים ב-LOOP.
  • הוספה או חיפוש… מציג את 60 ההתאמות הראשונות בפרויקט. הקלדת חלק גדול יותר מהשם מצמצמת את הרשימה.
  • הסתברויות OR הן אחוזים שלמים מ-0 עד 100.
  • איטרציות לולאה הן מספרים שלמים של 1 לפחות.
  • משכים אף פעם לא שליליים בסימולציה: ערך שלילי שנדגם נדגם מחדש.
  • בחירה במלבן בוחרת רק הערות. לרכיבי זרימה משתמשים ב-Shift-לחיצה.