Electronic Structure Analysis

Overview on electronic structure analysis computations

In order to enable a full ab-initio device simulation, microscopic input is required for the rate equations (implemented in LightForge) of all types of processes, namely all excitionics processes (including quenching) and charge transport. We will therefore run the following computations on morphologies generated with Deposit as described here:

Module/Mode Quantity to compute input
QP in Polarized mode layer-specific nergy disorder single-layer morphologies X_structurePBC.cml (X=meotpd_doped, anpd, anpd_irpiq or bphen)
QP in Matrix EAIP mode Material specific bsolute transport levels (EA/IP) single-layer morphologies X_structurePBC.cml (X=meotpd_doped, anpd, anpd_irpiq or bphen)
QP in Polarized mode including couplings Electronic couplings for all pairs in the system morphology of the reduced stack, stack_structurePBC.cml
QP in Lambda mode Reorganization energy of a single molecule of each type morphology of the reduced stack, stack_structurePBC.cml
Excitonic preprocessor Input for all excitonic rates, computed for a single molecule of each type morphology of the reduced stack, stack_structurePBC.cml

In the following you can find a detailed description of each computation, including links to the respective inputs from Deposit. You can either re-create these inputs using workflows described here, or download these files here

Setup of the QuantumPatch runs

The pre-configured workflows for QuantumPatch runs can be downloaded here. This file contains the following files:

  • QP_Disorder_X, X=MeoTPD, anpd, anpd_irpiq, BPhen, to compute energy disorder
  • QP_EAIP_X, X=MeoTPD, anpd, anpd_irpiq, BPhen, to compute absolute transport levels (EA, IP)
  • QP_Js_Stack, for the computation of electronic couplings
  • QP_Lambda, computation of reorganization energy of each compound
  • Excitonic preprocessing, to compute all input required for excitonics

Unzip this container in your local SimStack workflow directory (Configuration -> Paths -> Workflow Workspace) and restart SimStack to access the workflows. Remember to adapt paths to input files where needed. In the following you can find detailed description of the settings, if you wish to modify the workflows or re-create them from scratch.

Disorder

Energy disorder is required for each material. Note that for alpha-NPD, disorder computation is required for the pristine film and for the emission layer (alpha-NPD with Ir(piq)3), as energy levels of a material changes when mixed with another molecule. This results in a total of four disorder computations with the folling settings:

  • General:
    • Morphology: X_structurePBC.cml, X=MeoTPD, anpd, anpd_irpiq, BPhen
    • Run QuantumPatch: True
    • QuantumPatch Type: Polarized
    • Disable Js and in-vacuo Lambda/EA/IP calculation
    • Disregard molecular states
  • Engines: Two engines are required, one Turbomole engine used in the core shell and the first dynamic shell, and DFTB+ engine for the outer dynamic and the static shell. Additionally, we define a fallback engine for the core engine with tighter convergence criterion and, in the case of the anpd_irpiq morphology, another Turbomole fallback engine for the DFTB+ engine, as Ir is not supported by DFTB+. The fallback is always started whenever a single molecule computation in QP fails, either due to convergence or due to incompatible elements. Leave all settings not mentioned in the list below as is.
    • Turbomole core: Engine: Turbomole, Fallback enabled, Fallback Engine: "Turbomole FB" (see below), Functional: B3LYP, Basis: def2-SVP
    • Turbomole FB: Engine: Turbomole, FB: Fallback disabled, Functional: B3LYP, Basis: def2-SVP, SCF Convergence: superextreme
    • DFTB+ 1: Engine: DFTB+ (for anpd_irpiq: Fallback enabled, Fallback Engine: "TM BP FP" as defined below)
    • (for anpd_irpiq: TM BP FB: Engine: Turbomole, Functional: BP86, Basis: def2-SV
  • Shells: (keep "Different Engine on Last Iteration" disabled for all shells)
    • Core shell: Screened iterations, Inner Part Method: Number of molecules, Number of Molecules: 200, Used Engine: Turbomole core
    • Define three outer Shells:
      • Turbomole core, Shelltype dynamic, Cutoff Radius: 20.0 A
      • DFTB+ 1, Shelltype dynamic, Cutoff Radius: 25.0 A
      • DFTB+ 1, Shelltype static, Cutoff Radius: 60.0 A

Resources: A usual QuantumPatch run consists of a couple of hundreds to thousands quantum-chemistry calculations and should be run in parallel. For Disorder runs, we recommend to use 64 cores.

Computation of absolute values of EA and IP

Similar to energy disorder, absolute transport levels are required for each material, and seperate values are needed for pristine alpha-NPD and alpha-NPD mixed with Ir(piq)3. We therefore setup four EA/IP computations with the following settings:

  • General:
    • Morphology: X_structurePBC.cml, X=MeoTPD, anpd, anpd_irpiq, BPhen
    • Run QuantumPatch: True
    • QuantumPatch Type: Matrix EAIP
    • Disable Js and in-vacuo Lambda/EA/IP calculation
    • Molecular states: Leave as is (charge +-1, Multiplicity 2)
  • Engines: This now becomes a bit more complex, since we need to apply a different engine in the last iteration, in addition to a core shell with fallback and the environment shells with fallback. Similar to the disorder computation, leave all settings not mentioned as is.
    • TM Core: Engine: Turbomole, Fallback enabled, Fallback Engine: "TM core FB" (see below), Functional: wb97X, Basis: def2-SVP, 4 Threads and 6000MB RAM
    • TM Core LI: Engine: Turbomole, Fallback enabled, Fallback Engine: "TM core FB" (see below), Functional: B2PLYP, Basis: def2-SVP, 4 Threads and 6000MB RAM
    • TM Core FB: Engine: Turbomole, FFunctional: wb97X, Basis: def2-SVP, 4 Threads and 6000MB RAM, SCF convergence: superextreme
    • TM Core LI FB: Engine: Turbomole, FFunctional: B2PLYP, Basis: def2-SVP, 4 Threads and 6000MB RAM, SCF convergence: superextreme
    • TM env: Engine: Turbomole, Fallback enabled, Fallback Engine: "TM env FB" (see below), Functional: BP86, Basis: def2-SVP, 1 Threads and 1500MB RAM (standard)
    • TM env FB: Engine: Turbomole, Functional: BP86, Basis: def2-SVP, 1 Threads and 1500MB RAM (standard)
    • DFTB+ 1: Engine: DFTB+, Fallback enabled, Fallback Engine: "TM env FB" as defined above
  • Shells:
    • Define three outer Shells:
      • TM env, Shelltype dynamic, Cutoff Radius: 25.0 A
      • DFTB+ 1, Shelltype dynamic, Cutoff Radius: 35.0 A
      • DFTB+ 1, Shelltype static, Cutoff Radius: 45.0 A
    • For the core shell, leave screened iterations at 7 and Default molecular states as "0;1". Set "TM core" as engine, enable "Different Engine on Last Iteration" and set the Last Iteration Engine To "TM core LI". To identify on which molecules an EA and IP should be computed, do as follows:
      • For pristine samples, set Inner Part Method to "Number of Molecules" and set Number of Molecules to 10. If your computational resources and time allows, increase this number for higher accuracy.

      • For the mixed system, especially at low concentrations of emitters, with "Number of Molecules" it may occur that EA/IP is computed very few or none of the guest molecules. There is a tool called "GetInnerIDs.py" available to identify IDs of molecules close to the core in the QuantumPatch/MolecularTools directory. We therefore set Inner Part Method to "list of moelcule IDs" and

        • for the EML, supply the IDs of 10 host and 5 emitter molecules (in our case the emitter is rigid, so it is OK-ish to use fewer of them) close to the the core of the structure. For the anpd_irpiq_structurePBC.cml we generated and which is available for download, enter "molstate.0: 719;1192;1753;2409;6478;8170;8402;9132;9364;9475;776;1090;2394;4239;4744 | molstate.1: 719;1192;1753;2409;6478;8170;8402;9132;9364;9475;776;1090;2394;4239;4744" in the "list of Molecule IDs" field.
        • for MeoTPD, supply the IDs of the MeoTPD molecules (dopant is included on a parametric level to start with, so we do not need F4TCNQ values). In our morphology, the IDs of the 10 innermost MeoTPD molecules are 3533;3594;4415;4813;5521;6071;7154;7328;7449;9055 and we insert the string "molstate.0: 3533;3594;4415;4813;5521;6071;7154;7328;7449;9055 | molstate.1: 3533;3594;4415;4813;5521;6071;7154;7328;7449;9055" into the field in QuantumPatch.

        Remember that different structuctures require different IDs.

Resources: As for Disorder, EAIP computations should be run in parallel. For EAIP runs, we recommend to use 64 cores (or more, if available).

Electronic couplings

As electronic couplings are required for each type of pairs in the morphology, they need to be computed on morphologies that include all interfaces. We therefore use the periodically extended morphology of the reduced stack, stack_structurePBC.cml with the following QP settings:

  • General:
    • Morphology: stack_structurePBC.cml
    • Run QuantumPatch: True
    • QuantumPatch Type: Polarized
    • Calculate Js: enabled
    • Disable in-vacuo Lambda/EA/IP calculation
    • Disregard molecular states
  • Engines: For electronic couplings, BP86 is usually sufficient. Therefore, set the following engines (as usually, leave all settings not explicitly mentioned as is):
    • TM core: Engine: Turbomole, Fallback disabled, Functional: BP86, Basis: def2-SVP
    • DFTB+ 1: Engine: DFTB+, Fallback enabled, Fallback Engine: "TM core"
  • Shells:
    • Core shell: As we want to have molecules of all layers present, we can either go via list of molecules, or define an inner box such that just enough molecules (~150) of each species are present with sufficient environment. To validate which cutoff works, there is a tool named "GetNumberInnerMolsFromBox.py" in QuantumPatch/MolecularTools which prints you the number of molecules of each type for given cutoffs in x, y and z-direction and a given cml file. In our case values of 92.0A, 92.0A and 12.A for x-, y- and z-cutoff respectively resulted in 144 MeoTPD, 153 alpha-NPD, 46 Ir(piq)3 and 138 BPhen molecules present in the core box. There fore, set Inner Part Method to "Inner Box Cutoff" and supply these cutoffs. Then set TM core as engine.
    • Similar to the Disorder computation, define three outer shells:
      • Turbomole core, Shelltype dynamic, Cutoff Radius: 15.0 A
      • DFTB+ 1, Shelltype dynamic, Cutoff Radius: 25.0 A
      • DFTB+ 1, Shelltype static, Cutoff Radius: 60.0 A

Resources: The runtime for electronic couplings depends strongly on the number of pairs in the core shell. The more cores, the lower the walltime. 64 cores are sufficient, but will make you wait a bit.

Reorganization energies

It is sufficient to compute reorganization energies (lambdas) for a single molecule per type. In order to limit the number of QP-output files to parse to LightForge, we compute all lambdas in one go using stack_structurePBC.cml. QuantumPatch automatically computes lambda only for a single molecule per type present in the structure.

  • General:
    • Morphology: stack_structurePBC.cml
    • Run QuantumPatch: False
    • Include in-vacuo Lambda/EA/IP calculation: enabled
    • Disregard molecular states
  • Engines: Here, different engines for geometry optimization of charged molecules and single points are required, as well as a fallback engine each. As only few computations are done, we recommend to set the number of threads the number of cores available per node minus 1 (one master thread for QP required).
    • TM lambda: Engine: Turbomole, Fallback enabled, Fallback Engine: "TM L FB" (see below), Functional: M06-2X, Basis: def2-SVP, SCF Convergence: extreme, 31 Threads and 64000MB RAM
    • TM L FB: Engine: Turbomole, Fallback disabled, Functional: M06-2X, Basis: def2-SVP, SCF Convergence: superextreme, 31 Threads and 64000MB RAM
    • TM lambda geoopt: Engine: Turbomole, Fallback enabled, Fallback Engine: "TM L Geo FB" (see below), Functional: B3LYP, Basis: def2-SVP, SCF Convergence: extreme, Geometry Convergence: tight, 31 Threads and 64000MB RAM
    • TM L Geo FB: Engine: Turbomole, Fallback disabled, Functional: B3LYP, Basis: def2-SVP, SCF Convergence: superextreme, Geometry Convergence: tight, 31 Threads and 64000MB RAM
  • Shells: Nothing to do here (only relevant for Polarized or Matrix EAIP)
  • LambdaEAIP tab:
    • enable Calculate Lambda
    • Lambda Type: Both
    • Disable EA, IP and Vertical EA/IP
    • Engine for Geometry Optimizations: TM lambda geoopt
    • Engine for Single Points: TM lambda

Note that Lambdas can also be done in the same run as electronic couplings. As the lambda computations for different molecules or charged states are not yet done in parallel, however, this may lead to idle time of parts of the allocated resources, if multiple nodes are allocated.

Resources: The multiple computations in the Lambda run are not yet parallelized beyond the parallelization of the engines. Therefore, allocate a single node with 32 cores, if you defined 31 threads in the engine (one master thread for QuantumPatch required).

Input for excitonics

Similar to lambda, the input for excitonics is only computed for a single molecule per type in any given morphology. Therefore, we set the following parameters in the ExcitonicPreProcessor module (note: this is based on QuantumPatch, but comes as an individual module in SimStack).

  • Start with the Engines tab and define two engines:
    • Turbomole core: Engine: Turbomole, Fallback enabled, Fallback Engine: "Turbomole FB" (see below), Functional: wb97X, Basis: def2-SVP, 31 Threads and 64000MB RAM
    • Turbomole FB: Engine: Turbomole, Fallback disabled, Functional: M06-2X, Basis: def2-SVP, SCF Convergence: superextreme, 31 Threads and 64000MB RAM
    • Dalton: Set threads to 16 and Memory to 32000MB, leave rest as is.
  • General: Enable Fluorescence with Turbomole core, Phosphorescence with Dalton 1, TTA with 20 roots and Turbomole core, TPQ with anion, cation, 20 roots and Turbomole core
  • Shells: Set Inner Part Method to "List of Molecule IDs" and supply the ID of one molecule per type each. In our stack_structurePBC.cml, enter "molstate.0: 2104;1128;1424;260" into the respective field.

Resources: Similar to the Lambda run , a single node with 32 cores is a good choice, if you defined 31 threads in the engine (one master thread for QuantumPatch required).

Output

From each QuantumPatch run, download the "Analysis.zip" file and label them as follows for later usage:

  • Disorder runs: X_Disorder_Analysis.zip, X=MeoTPD, ANPD, ANPD_Irpiq, BPhen
  • EA/IP runs: X_EAIP_Analysis.zip, X=MeoTPD, ANPD, ANPD_Irpiq, BPhen
  • Electronic couplings: Js_Analysis.zip
  • Reorganization energies: Lambda_Analysis.zip
  • Excitonics: Excitonics_Analysis.zip

In the following we give a brief summary over the results of the electronic structure analysis. All output files of all QuantumPatch runs are available here, labeled as mentioned above.

Electronic transport levels

Ihe table below you can find absolute transport levels (EA/IP):

Material EA / eV IP / eV
MeoTPD -1.367 -4.911
alpha-NPD pristine -1.894 -5.370
alpha-NPD mixed -1.835 -5.594
Ir(piq)3 -2.351 -5.458
BPhen -2.216 -6.656

and energy disorder:

Material Disorder EA / eV Disorder IP / eV
MeoTPD 0.144 0.191
alpha-NPD pristine 0.110 0.094
alpha-NPD mixed 0.160 0.136
Ir(piq)3 0.119 0.123
BPhen 0.176 0.174

Troubleshooting

In case you encounter difficulties following this tutorial, please send us an email at info@nanomatch.com .

The results of the search are