בית דוגמאות צילומי מסך מדריך למשתמש הלוגו של בלוסקיי YouTube ☰
OghmaNano פלטפורמת סימולציה רב-פיזיקלית עבור התקנים אופטו-אלקטרוניים ומערכות פוטוניות הורד מדריך להתחלה מהירה

תכנות באמצעות שפת Pythonתכנות באמצעות שפת Python

1. מבוא1. מבוא

ב-OghmaNano, סקריפטים של Python פועלים על ידי עריכה ישירה של קבצי התצורה של הסימולציה בדיסק, ולאחר מכן הפעלת מנוע הסימולציה (oghma_core.exe) כדי להריץ את המודל. בחלק זה מתואר תהליך העבודה הזה בפירוט.ב-OghmaNano, סקריפטים של Python פועלים על ידי עריכה ישירה של קבצי התצורה של הסימולציה בדיסק, ולאחר מכן הפעלת מנוע הסימולציה (oghma_core.exe) כדי להריץ את המודל. בחלק זה מתואר תהליך העבודה הזה בפירוט.

2. הפעלת קבצי סימולציה באמצעות Python.2. הפעלת קבצי סימולציה באמצעות Python.

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

כאשר מפעילים את OghmaNano מתוך סקריפט Python, הסקריפט קורא את הנתונים sim.json לזיכרון באמצעות הספריה הסטנדרטית json של Python, משנה פרמטר אחד או יותר, ושומר את קובץ ה-JSON המעודכן בחזרה בדיסק.כאשר מפעילים את OghmaNano מתוך סקריפט Python, הסקריפט קורא את הנתונים sim.json לזיכרון באמצעות הספריה הסטנדרטית json של Python, משנה פרמטר אחד או יותר, ושומר את קובץ ה-JSON המעודכן בחזרה בדיסק.

חשוב מכך, יש להריץ את סקריפט Python כאשר תיקיית העבודה שלו מוגדרת לתיקיית הסימולציה – כלומר, התיקייה המכילה את sim.json (וגם את sim.oghma). זוהי התיקייה שממנה מופעל oghma_core.exe.חשוב מכך, יש להריץ את סקריפט Python כאשר תיקיית העבודה שלו מוגדרת לתיקיית הסימולציה – כלומר, התיקייה המכילה את sim.json (וגם את sim.oghma). זוהי התיקייה שממנה מופעל oghma_core.exe.

לאחר שמעדכנים את קובץ ה-JSON, התסריט מפעיל את oghma_core.exe מאותה תיקייה. מנוע הסימולציה תמיד קורא את קבצי הקלט שלו מהתיקייה הנוכחית שבה הוא פועל, ולכן אם תיקיית העבודה אינה נכונה, הסימולציה תיכשל או תריץ את המודל הלא נכון.לאחר שמעדכנים את קובץ ה-JSON, התסריט מפעיל את oghma_core.exe מאותה תיקייה. מנוע הסימולציה תמיד קורא את קבצי הקלט שלו מהתיקייה הנוכחית שבה הוא פועל, ולכן אם תיקיית העבודה אינה נכונה, הסימולציה תיכשל או תריץ את המודל הלא נכון.

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

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


       import json
       import os
       import sys

       f=open('sim.json')              #open the sim.json file
       lines=f.readlines()
       f.close()
       lines="".join(lines)    #convert the text to a python json object
     data = json.loads(lines)

     #Edit a value (use firefox as a json viewer
     # to help you figure out which value to edit)
     # this time we are editing the mobility of layer 1
     data['epitaxy']['segment1']['shape_dos']['mue_y']=1.0


     #convert the json object back to a string
     jstr = json.dumps(data, sort_keys=False, indent='\t')

     #write it back to disk
     f=open('sim.json',"w")
     f.write(jstr)
     f.close()

     #run the simulation using oghma_core
     os.system("oghma_core.exe")

אם הסימולציה ב-sim.json מוגדרת כך שתבצע הדמיה של עקומת J–V, OghmaNano תיצור קבצי פלט בספריית הסימולציה, אשר יכילו נתונים כגון PCE, מקדם מילוי, \(J_{sc}\) ו-\(V_{oc}\).אם הסימולציה ב-sim.json מוגדרת כך שתבצע הדמיה של עקומת J–V, OghmaNano תיצור קבצי פלט בספריית הסימולציה, אשר יכילו נתונים כגון PCE, מקדם מילוי, \(J_{sc}\) ו-\(V_{oc}\).

הדוגמה שלהלן מציגה כיצד לקרוא קובץ פלט בפורמט JSON ולצרף את הערך של \(V_{oc}\) לקובץ טקסט נפרד.הדוגמה שלהלן מציגה כיצד לקרוא קובץ פלט בפורמט JSON ולצרף את הערך של \(V_{oc}\) לקובץ טקסט נפרד.

f=open('sim_info.dat')
lines=f.readlines()
f.close()
lines="".join(lines)
data = json.loads(lines)

f=open('out.dat',"a")
f.write(str(data["Voc"])+"\n");
f.close()

3. סימולציות מורכבות יותר3. סימולציות מורכבות יותר

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

הדוגמה שלהלן יוצרת סדרה של תיקיות, כאשר כל תיקייה מתאימה לאחד מארבעת סוגי הניידות (1e-5, 1e-6, 1e-7, 1e-8). עבור כל תיקייה, היא מבצעת את הפעולות הבאות:הדוגמה שלהלן יוצרת סדרה של תיקיות, כאשר כל תיקייה מתאימה לאחד מארבעת סוגי הניידות (1e-5, 1e-6, 1e-7, 1e-8). עבור כל תיקייה, היא מבצעת את הפעולות הבאות:

  1. יוצר את התיקייה (אם היא עדיין לא קיימת).יוצר את התיקייה (אם היא עדיין לא קיימת).
  2. מעתיק את הגרסה הנוכחית של sim.json לספרייה זו.מעתיק את הגרסה הנוכחית של sim.json לספרייה זו.
  3. עורך את הנתונים המועתקים של sim.json כדי להגדיר את ערך הניידות הרצוי.עורך את הנתונים המועתקים של sim.json כדי להגדיר את ערך הניידות הרצוי.
  4. משנה את ספריית העבודה לספרייה הנוכחית.משנה את ספריית העבודה לספרייה הנוכחית.
  5. מפעיל את הפותר בספרייה זו, ומייצר פלט ששמור באופן מקומי עבור הרצה זו.מפעיל את הפותר בספרייה זו, ומייצר פלט ששמור באופן מקומי עבור הרצה זו.

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


       import json
       import os
       import shutil

       # The script must be started in the base simulation directory
       # (i.e. the directory containing the reference sim.json).
       base_dir = os.getcwd()

       mobilities = [1e-5, 1e-6, 1e-7, 1e-8]

       for mu in mobilities:
           # Create a directory name that is easy to read and sorts nicely
           run_dir = os.path.join(base_dir, f"mu_{mu:.0e}")
           os.makedirs(run_dir, exist_ok=True)

           # Copy the base sim.json into the run directory
           src_sim = os.path.join(base_dir, "sim.json")
           dst_sim = os.path.join(run_dir, "sim.json")
           shutil.copyfile(src_sim, dst_sim)

           # Load the copied sim.json and edit the mobility in THAT copy
           f = open(dst_sim)
           lines = f.readlines()
           f.close()
           lines = "".join(lines)
           data = json.loads(lines)

           # Edit a value: set the mobility for the first device layer
           data['epitaxy']['segment1']['shape_dos']['mue_y'] = mu

           jstr = json.dumps(data, sort_keys=False, indent='\t')
           f = open(dst_sim, "w")
           f.write(jstr)
           f.close()

           # Change into the run directory and execute the solver there
           os.chdir(run_dir)

           # If your command is "augment.nano" instead, replace the string below.
           os.system("oghma_core.exe")

           # Return to the base directory for the next run
           os.chdir(base_dir)

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

שרטוט \(V_{oc}\) כנגד ההופכי של הניידותשרטוט \(V_{oc}\) כנגד ההופכי של הניידות

לאחר שהרצתם סדרת הדמיות בספריות נפרדות, השלב הבא הוא בדרך כלל לחלץ מדד ביצועים מרכזי מכל הרצה ולהציג את המגמה הגרפית. דוגמה נפוצה היא לקרוא את מתח המעגל הפתוח \(V_{oc}\) מקובץ הפלט בפורמט JSON (sim_info.dat) ולשרטט אותו כנגד הניידות ההפוכה \(1/\mu\).לאחר שהרצתם סדרת הדמיות בספריות נפרדות, השלב הבא הוא בדרך כלל לחלץ מדד ביצועים מרכזי מכל הרצה ולהציג את המגמה הגרפית. דוגמה נפוצה היא לקרוא את מתח המעגל הפתוח \(V_{oc}\) מקובץ הפלט בפורמט JSON (sim_info.dat) ולשרטט אותו כנגד הניידות ההפוכה \(1/\mu\).

הסקריפט המצורף סורק סדרה של תיקיות (לדוגמה mu_1e-05, mu_1e-06...) ולכל תיקייה:הסקריפט המצורף סורק סדרה של תיקיות (לדוגמה mu_1e-05, mu_1e-06...) ולכל תיקייה:

  1. טען את הנתונים sim_info.dat בפורמט JSON.טען את הנתונים sim_info.dat בפורמט JSON.
  2. קטעים Voc.קטעים Voc.
  3. מחשב את \(1/\mu\) באמצעות הניידות המשויכת לספרייה זו.מחשב את \(1/\mu\) באמצעות הניידות המשויכת לספרייה זו.
  4. יוצר קובץ סיכום קצר (voc_vs_inv_mobility.dat).יוצר קובץ סיכום קצר (voc_vs_inv_mobility.dat).
  5. גרפים \(V_{oc}\) לעומת \(1/\mu\).גרפים \(V_{oc}\) לעומת \(1/\mu\).

       import json
       import os

       # Optional: plotting (requires matplotlib)
       import matplotlib.pyplot as plt

       base_dir = os.getcwd()

       # Mobilities must match the run directories you generated earlier
       mobilities = [1e-5, 1e-6, 1e-7, 1e-8]

       inv_mu = []
       vocs = []

       for mu in mobilities:
           run_dir = os.path.join(base_dir, f"mu_{mu:.0e}")
           info_path = os.path.join(run_dir, "sim_info.dat")

           # Read the JSON output file and extract Voc
           f = open(info_path)
           lines = f.readlines()
           f.close()
           lines = "".join(lines)
           data = json.loads(lines)

           voc = data["Voc"]

           inv_mu.append(1.0 / mu)
           vocs.append(voc)

       # Write a small summary table to disk
       out = open("voc_vs_inv_mobility.dat", "w")
       out.write("# inv_mobility(1/mu)    Voc(V)\n")
       for x, y in zip(inv_mu, vocs):
           out.write(f"{x:.6e}    {y}\n")
       out.close()

       # Plot Voc against inverse mobility
       plt.plot(inv_mu, vocs, "o-")
       plt.xlabel("Inverse mobility (1/μ)")
       plt.ylabel("Open-circuit voltage Voc (V)")
       plt.title("Voc vs inverse mobility")
       plt.grid(True)
       plt.tight_layout()
       plt.show()

🎬 סרטון קשור🎬 סרטון קשור

הסרטון שלהלן מדגים כיצד ניתן להשתמש ב-OghmaNano באמצעות תסריטי Python.הסרטון שלהלן מדגים כיצד ניתן להשתמש ב-OghmaNano באמצעות תסריטי Python.

הערה: ממשק ה-API וממשק התסריטים הפנימי המוצגים בסרטון אינם בשימוש עוד ואינם כלולים בגרסאות האחרונות, מכיוון שהתברר כי קשה לתחזק אותם. השיטה הנוכחית והמומלצת היא להשתמש בתסריט Python חיצוני כדי לערוך ישירות את קבצי הסימולציה בפורמט JSON, ולאחר מכן להפעיל את oghma_core.exe. גישה זו פשוטה יותר, יציבה יותר וקלה יותר לתחזוקה. ייתכן שהסרטון עדיין יהיה שימושי להבנת תהליך העבודה הכללי ומקרי השימוש הטיפוסיים, אך לשיטה העדכנית ביותר, אנא עקבו אחר השלבים המתוארים לעיל.הערה: ממשק ה-API וממשק התסריטים הפנימי המוצגים בסרטון אינם בשימוש עוד ואינם כלולים בגרסאות האחרונות, מכיוון שהתברר כי קשה לתחזק אותם. השיטה הנוכחית והמומלצת היא להשתמש בתסריט Python חיצוני כדי לערוך ישירות את קבצי הסימולציה בפורמט JSON, ולאחר מכן להפעיל את oghma_core.exe. גישה זו פשוטה יותר, יציבה יותר וקלה יותר לתחזוקה. ייתכן שהסרטון עדיין יהיה שימושי להבנת תהליך העבודה הכללי ומקרי השימוש הטיפוסיים, אך לשיטה העדכנית ביותר, אנא עקבו אחר השלבים המתוארים לעיל.

שימוש בשפת התכנות Python ליצירת סקריפט לסימולציה של תא סולארי מבוסס פרובסקיט בתוכנת OghmaNano.שימוש בשפת התכנות Python ליצירת סקריפט לסימולציה של תא סולארי מבוסס פרובסקיט בתוכנת OghmaNano.