Δημιουργία σεναρίων με Python

1. Εισαγωγή

Στο OghmaNano, η χρήση σεναρίων Python γίνεται μέσω της άμεσης επεξεργασίας των αρχείων διαμόρφωσης της προσομοίωσης στον δίσκο και στη συνέχεια της ενεργοποίησης της μηχανής προσομοίωσης (oghma_core.exe) για την εκτέλεση του μοντέλου. Αυτή η ενότητα περιγράφει λεπτομερώς αυτή τη διαδικασία.

2. Εκτέλεση αρχείων προσομοίωσης με χρήση της Python.

Μια προσομοίωση OghmaNano ορίζεται εξ ολοκλήρου από ένα μόνο αρχείο διαμόρφωσης JSON, sim.json. Αυτό το αρχείο περιέχει την πλήρη κατάσταση της προσομοίωσης, συμπεριλαμβανομένης της δομής της συσκευής, των παραμέτρων των υλικών, των αριθμητικών ρυθμίσεων και της διαμόρφωσης εξόδου. Σε πολλές περιπτώσεις, sim.json υπάρχει ήδη ως ένα κανονικό αρχείο μέσα στον κατάλογο της προσομοίωσης.

Όταν χρησιμοποιείτε το OghmaNano μέσω Python, το σενάριο διαβάζει το αρχείο sim.json στη μνήμη χρησιμοποιώντας την τυπική βιβλιοθήκη json της Python, τροποποιεί μία ή περισσότερες παραμέτρους και αποθηκεύει ξανά το ενημερωμένο αρχείο JSON στον δίσκο.

Είναι ζωτικής σημασίας το σενάριο Python να εκτελείται με τον κατάλογο εργασίας ρυθμισμένο στον κατάλογο της προσομοίωσης – δηλαδή, στον κατάλογο που περιέχει τα αρχεία sim.json και sim.oghma. Αυτός είναι ο κατάλογος από τον οποίο εκκινούνται οι λειτουργίες του oghma_core.exe.

Μόλις ενημερωθεί το αρχείο JSON, το σενάριο εκκινεί το oghma_core.exe από τον ίδιο κατάλογο. Η μηχανή προσομοίωσης διαβάζει πάντα τα αρχεία εισόδου από τον τρέχοντα κατάλογο εργασίας, επομένως εάν ο κατάλογος εργασίας είναι λανθασμένος, η προσομοίωση θα αποτύχει ή θα εκτελέσει το λάθος μοντέλο.

Αυτός ο διαχωρισμός των αρμοδιοτήτων είναι σκόπιμος και σαφής: η Python είναι υπεύθυνη για τον καθορισμό των αλλαγών στην προσομοίωση, ενώ η OghmaNano είναι υπεύθυνη για την εκτέλεση των φυσικών υπολογισμών χρησιμοποιώντας τα αρχεία που υπάρχουν στον τρέχοντα κατάλογο.

Το παρακάτω παράδειγμα απεικονίζει αυτή τη διαδικασία, φορτώνοντας το 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}\).

Το παρακάτω παράδειγμα δείχνει πώς να διαβάσετε ένα αρχείο εξόδου 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. Πιο σύνθετες προσομοιώσεις.

Σε πολλές διαδικασίες δημιουργίας σεναρίων, θα θέλετε να εκτελέσετε την ίδια βασική προσομοίωση πολλές φορές, χρησιμοποιώντας διαφορετικές τιμές παραμέτρων και διατηρώντας κάθε εκτέλεση απομονωμένη σε έναν ξεχωριστό φάκελο. Αυτός είναι ο απλούστερος τρόπος για να διατηρήσετε τα αποτελέσματα οργανωμένα και να αποφύγετε την ακούσια αντικατάσταση των προηγούμενων αποτελεσμάτων.

Το παρακάτω παράδειγμα δημιουργεί ένα σύνολο καταλόγων που αντιστοιχούν σε τέσσερις κινητικότητες (1e-5, 1e-6, 1e-7, 1e-8). Για κάθε κατάλογο, εκτελεί τις ακόλουθες ενέργειες:

1. Δημιουργεί τον φάκελο (εάν δεν υπάρχει ήδη).
2. Αντιγράφει το τρέχον sim.json σε αυτόν τον κατάλογο.
3. Επεξεργάζεται το αντίγραφο sim.json για να ορίσει την επιθυμητή κινητικότητα.
4. Αλλάζει τον τρέχοντα κατάλογο εργασίας στον συγκεκριμένο κατάλογο.
5. Εκτελεί τον επιλυτή στον συγκεκριμένο κατάλογο, παράγοντας αποτελέσματα που αποθηκεύονται τοπικά για αυτήν την εκτέλεση.

Αυτό το μοτίβο αποτελεί τη βάση της δημιουργίας σεναρίων παρτίδας στο 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}\) από το αρχείο εξόδου JSON (sim_info.dat) και η γραφική της παράσταση σε σχέση με την αντίστροφη κινητικότητα \(1/\mu\).

Το παρακάτω σενάριο ελέγχει μια σειρά από καταλόγους εκτέλεσης (για παράδειγμα mu_1e-05, mu_1e-06, ...) και για κάθε κατάλογο:

1. Φορτώνει sim_info.dat ως JSON.
2. Αποσπάσματα Voc.
3. Υπολογίζει το \(1/\mu\) χρησιμοποιώντας την κινητικότητα που σχετίζεται με τον συγκεκριμένο κατάλογο.
4. Δημιουργεί ένα μικρό αρχείο περίληψης (voc_vs_inv_mobility.dat).
5. Γραφήματα \(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.

Σημείωση: Το API και η εσωτερική διεπαφή scripting που παρουσιάζονται στο βίντεο δεν υποστηρίζονται πλέον και δεν περιλαμβάνονται στις τρέχουσες εκδόσεις, καθώς αποδείχθηκε ότι ήταν δύσκολο να συντηρηθούν. Η τρέχουσα και συνιστώμενη μέθοδος είναι η χρήση ενός εξωτερικού script Python για την απευθείας επεξεργασία των αρχείων προσομοίωσης JSON και στη συνέχεια την εκκίνηση του oghma_core.exe. Αυτή η προσέγγιση είναι απλούστερη, πιο αξιόπιστη και ευκολότερη στη συντήρηση. Μπορείτε ακόμα να βρείτε το βίντεο χρήσιμο για την κατανόηση της συνολικής ροής εργασίας και των τυπικών περιπτώσεων χρήσης, αλλά για την πιο πρόσφατη μέθοδο, ακολουθήστε τα βήματα που περιγράφονται παραπάνω.