Matrix EA/IP Calculations
To successfully simulate properties of a electronic device with LightForge ab initio -- i.e. without outside parameters -- you will need to run multiple QuantumPatch simulations first to generate input values. An important set of those values are Electron Affinities (EA), Ionization Potentials (IP).
While Disorder (sigma) values and site interaction energies (J) are calculated in so-called Polarized runs, a run to calculate EA, IP of a molecule also utilizes Polaron runs. The latter will put a net charge on one center molecule and relax the charge cloud environment. In consequence one Polaron relaxation will only be run on one center molecule and multiple runs will be needed to achieve significant statistics.
The Matrix EA/IP run will start by obtaining the neutral system energy via a Polarized charge cloud relaxation, followed by anion (negative net charge) and cation (positive net charge) Polaron runs to get charged energies. The differences between charged and neutral energies finally yield the EA and IP for your system. Note that we recommend to use this mode to compute absolute IP levels, as well as IP and EA levels for coulomb binding energy computations. Absolute EA levels should be computed in vacuum following the EA tutorial.
In this subsection we will be explaining how to set up a Matrix EA/IP calculation within a workflow with the QuantumPatch node of SimStack. Open your SimStack client and pull in the QuantumPatch3 node from the nodes panel on the left.
Under the General tab of the QuantumPatch3 WaNo you can enter your morphology structure file you created beforehand with Deposit; on information on how to do that we recommend you check out one of our webinars, for example the deposition of amorphous thin-films which will also explain how to use the Parametrizer and Dihedralparametrizer WaNos. We recommend expanding morphologies in x and y directions (enable the checkbox in the box labeled PBC in the Deposit WaNo) to ensure a 60 Å environment does not contain vacuum. Then adapt the following settings:
- Run QuantumPatch: True
- QuantumPatch Type: Matrix EAIP
- Disable Js and in-vacuo Lambda/EA/IP calculation
- Molecular states: These settings determine the state of the core molecules in the QP evaluation. For IP, set charge=+1, multiplicity=2, for EA, set charge=-1, multiplicity=2. If you define more than one molstate (using the "+"-button), the molstates can in the shells tab be referenced as molstate.0, molstate.1, etc. according to their order here. Leave the Excited State of Interest and Roots boxes untouched since those are only relevant for calculations involving electronic excitations (e.g. Exciton Preprocessor runs).
To optimize accuracy vs. runtime, we equilibrate the system using wb97x, but use a different engine in the last iteration for evaluation of molecular total energies. In addition we define fallbacks and the environment shells with fallback. Leave all settings not mentioned explicitly in the following 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
- 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. 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 at least 10. If your computational resources and time allows, increase this number for higher accuracy. If "Number of Molecules" is used, please remember to adapt Default molecular states according to the molecular states you wish to compute as defined in the General tab. "0;1" in this field in combination with 10 in the Number of Molecules field would e.g. compute both molstate.0 and molstate.1 on the 10 innermost molecules.
For more detailed computation setup, you can also provide a list of molecule IDs. E.g. for 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. List of Molecule IDs will create a field list of molecule IDs which will let you enter one free-form line of input. List entries are separated with the pipe | symbol, each section separated by pipes will describe a separate QuantumPatch simulation. Molecule IDs within one list are separated by a semicolon ; while ranges can be defined by a dash -. For example, if MolState 0 is applied to molecules 0, 1, and all molecules from 21 to 36, the list entry would be:
molstate.0: 0;1;21-36 | .... As an example, if the list is defined by
molstate.0: 0-100 | molstate.1: 0-100 | molstate.2: 1-15, it will cause QuantumPatch to first calculate molecules 0 to 99 all in MolState 0, then to start a new run with molecules 0 to 99 calculated in MolState 1, then a new run is executed with now only molecules 1 to 14 being put into MolState 2. Note that ranges of IDs (i.e. 1-15) are given in a programmer's notation, meaning the highest number (15 in this example) is excluded from the calculation (molecules 1 to 14 are calculated). Remember that different structuctures may require different IDs. FOr better understanding, let's look at an example: Entering the list
molstate.0: 24;27;31;45;61 | molstate.1: 28-30;33;36will cause QuantumPatch to execute
- 10 polarized runs for all entered molecules in their ground state,
- 5 polaron runs in molstate 0 for molecule ids 24, 27, 31, 45, and 61,
- 5 polaron runs in molstate 1 for molecule ids 28 through 29, 33, and 36.
Note that you do not need to separate your molecule IDs into different molecule types, QuantumPatch does that automatically once it reaches its analysis stage and output will be generated for each different type of molecule. To be able to select molecule IDs manually we recommend using a visualization program for your morphology, e.g. Jmol (Molecule IDs start at number 1 whereas in QuantumPatch enumeration starts at 0, so you will have to subtract 1 from each molecule ID chosen from Jmol) or PyMOL.
You can find computed EA and IP levels in yaml-dictionaries labeled eaip_moltypeIP_summary.yml or eaipmoltype_EA_summary.yml in the subfolder 'Analysis/EAIP' of the QP job. The moltype is a 32-digit alphanumeric hash we use to identify molecules and assign data to molecule types in various simulation modules. The IP levels are listed in the entry labeled "mean_single_delta_corrected". Once more, please note that only IP levels computed as described above provide a certain accuracy. For EA levels, please follow this tutorial instead.
The results of the search are