View source for Plotting Examples - new short version

== Plotting in Flooxs ==

If you would like a comprehensive explanation of all the flooxs post-processing commands, see the following link: [[Post Processing Commands]]

This section presents examples of the most-common plotting scenarios, including examples of the '''plot.?d''', '''CreateGraphWindow''', and '''layers''' command.


== The plot.?d Method ==
This is useful quickly plotting from the command line as you are debugging.


=== plotting the grid ===
The plot.?d grid function uses the grid definition you typed in before your init to draw the grid, i.e. it uses these lines of your script to plot the grid"
 line x loc=... 
 region Oxide xlo=...
If you use struct outf=filename.str to store your grid structure solution values, the grid is stored for the purposes of solving on the grid, and not for plotting. So if you the use init inf=filename.str in another file, your grid will be stored for equation solving, and your solution variables will be stored, but you will not be able to plot the grid. You have to plot the grid in the deck you have typed your line x loc=... etc.

'''example 1: plotting the grid in 2d:'''
 plot.2d grid;# draw grid lines in a plot window, with different colors for different materials
 plot.2d bound !cle;# draw black lines to represent the boundaries between different material regions
 plot.2d contact=Top !cle;# mark a red symbol on grid nodes that have a contact named "Top" on it
 foreach nam {Top Left Rigt Bot} {plot.2d contact=$nam !cle};# use a loop for all contacts

Note: there is no plot.1d grid, but you may see the grid spacing in 1D with the plot.1d command:
 sel z=Elec ;#you must select something, even if you have not solved for it
 plot.1d x.v=0.0 symb=1 ;# this marks a symbol on each grid point

Note: to plot the grid in 3d: you have to save out a file and use [[Tecplot]] to view it

=== plotting variables and expressions ===
'''example 2: plotting Doping, Elec, and Hole concentration'''

First, select what you want to plot, e.g. one of these:
 sel z=Elec ;# you can select any variable you have defined in floods
 sel z=log10(abs(Elec+1e-10);# you can select any expression Alagator can parse
 sel z=sign(Charge)*log10(abs(Charge));# if you want to know the sign of the original variable
Note: I took the absolute value of Elec before I took it's log, and I also added a very small number, 1e-10, which is approximately zero, because you can't take the log of a negative number, or of zero.

Then, use the plot.?d command, specifying slices where appropriate.
 plot.1d ;#for a 1d simulation
 plot.1d y.v=0 ;#take 1 slice at y=0 for a 2d simulation
 plot.1d y.v=0 z.v=0;# 2 slices for a 3d simulation

Here's a tcl loop that plots Doping, Elec and Hole on the same plot, with a label:
 foreach var {Doping Elec Hole} {sel z=$var; plot.1d y.v=0.0 label=$var !cle}
Note: "!cle" means "don't clear the previous plot"
Note: using "label=some.name" makes your key on the plot window decipherable

'''example 3: plotting a band diagram'''
Here's a tcl loop that plots the previously defined variables Ec, Efn, and Efp. 
 foreach var {Ec Efn Efp Ev} {sel z=$var; plot.1d y.v=0 label=$var !cle}


== The CreateGraphWindow Method ==
Here is an example of how to plot Electron concentration using the CreateGraphWindow method:
 set WinElec [CreateGraphWindow] ;# store the plot channel in a variable
 sel z=Elec ;# choose the variable for the y-axis
 CreateLine $WinElec Elec.per.cm3 [slice Oxide x=0.0];# Elec.per.cm3 is a name for the plot key

CreatGraphWindow is most useful during loops. For example, you can use AddToLine to make Id-Vg plots in a MosFET, or to plot the creation of interface traps vs time:

'''example 4: plot an Id-Vg curve for a MOSFET'''
 #Ramp drain voltage up first (changes Fermi level least)
 for {set bias 0.0} {$bias <= 1.0} {set bias [expr {$bias + 0.1}]} {
    puts \n
    contact name=D voltage supply=$bias
    puts "Ramping D to $bias"
    device
 
    #PlotBands y.v=36.0 z.v=0.0
    #PlotConc_old y.v=0.250 z.v=-1.0
 }
 
 #Ramp gate up
 set Win_IdVg [CreateGraphWindow]
 set delta 0.01
 for {set bias 0.0} {$bias <= 1.0} {set bias [expr {$bias - $delta}]} {
    puts \n
    contact name=G voltage supply=$bias
    puts "Ramping G to $bias"
    device
 
    #get current from the drain (choose regular or log)
    set cur [expr abs([contact name=D sol=Elec flux] - [contact name=D sol=Hole flux])]
    #set cur log10($cur+1e-10)
    AddtoLine $Win_IdVg IdVg $bias $cur;#channel, name, x-val, y-val
 
    #PlotBands y.v=24 z.v=0.0
    #PlotConc_old y.v=0.250 z.v=-1.0
    #if {$VG < -15.0} {set delta 0.05}
    #if {$VG < -20.0} {set delta 0.05}
 }



'''example 5: plot concentration of interface traps (Nit) vs. time'''
 set WinNit [CreateGraphWindow];# channel name
 device time=420 init=1e-12 movie = {
    set t [simGetDouble Device time];#returns t in seconds
    sel z=Nit;# select the variable for the y-axis
    AddtoLine $WinNit Nit $t [interface value Silicon /Oxide];#Nit here is a name for the plot key

== Saving Plots As Images from the Command Line ==
This is a procedure I use for saving .gif images of my plots in a PLOTS directory that I have previously created:
 #proc for saving the graph as gif image
 proc SnapImage {win_val filename} {
 	puts $win_val ".graph snap .image"
 	puts $win_val ".image write PLOTS/$filename.gif -format gif"
 	flush $win_val
 }

If you have called all your plot channel Win$var, where $var is a var name such as Elec, then you use this loop to save each of your plots as a .gif image, or use this example to write your own.
 foreach var {Elec Hole Nit Doping} {
 	eval set win_val "\$Win$var"
 	SnapImage $win_val $var
 }

== Integrating with the Layers Command ==
You might want to know how much of a certain variable (usually charge) is in a certain layer. For this, you can use the '''layers''' command. This will ask floods to integrate your /cm^3 variable along a certain line, and gives you how much charge is in a layer /cm^2.

To use the layers command, first you select the variable you want integrated; then you specify the line or plane you want floods to integrates along; floods then integrates along that line, separately in each material, and separately within materials if there is a sign change in the variable you've given it; finally, floods prints a list like this (this example is a 1D moscap structure):
 flooxs> sel z=Elec-1e14
 sel z=Elec-1e14
 Parsing Equation...
 
 flooxs> layers
 layers
 {         Top          Bottom        Integral    Material}
 {-1.20000e+00     0.00000e+00    -1.20000e+10    Oxide}
 { 0.00000e+00     5.00000e+00     5.05845e+11    Silicon}


If I had an inversion layer it would look more like:
 {         Top          Bottom        Integral    Material}
 {-1.20000e+00     0.00000e+00    -1.20000e+10    Oxide}
 { 0.00000e+00     0.030000e+00     5.05845e+11    Silicon}
 { 0.03000e+00     5.00000e+00     1.05845e+10    Silicon}
and you could tell that the inversion layer thickness was 0.03um in Silicon, and that the total charge in the inversion layer (you can get capacitance if you graph this vs top gate voltage, then take the slope) is 5.05e11 Elec/cm^2.


Below I have 2 procedures that I use for different codes - the first gets the inversion layer depth if you give it the variable and the threshold, e.g. you can do either:
 InversionLayer Elec 1.0e14;# to print to screen
 set inv_depth [InversionLayer Elec 1.0e15];# to store in inv_depth
The second gets the total electron concentration in the oxide of a mos structure (must have oxide as first material in x):
 set totelec [GetTotElec];# in case you wanted to, say, plot this at different time steps

These procs have extra lines that use tcl to search the floods output list and find the number I want in the material I want. Unfortunately they're fairly specific to what I was doing (i.e. it doesn't look for "oxide" or anything like that, it just counts entries and gets the same one every time).
 proc InversionLayer {var thresh} {
    sel z=($var-$thresh)
    set percm2 [layers y.v=0.250 z.v=-4.0];#center of the structure
    set percm2 [KillChar $percm2 \{];#kill the brackets
    set percm2 [KillChar $percm2 \}]
    set percm2 [split $percm2 \n];# split into list at newline
    set percm2 [lindex $percm2 3];# return third element of list (Silicon)
    set percm2 [split $percm2 \t]
    #inversion layer depth
    set xinv [KillChar [lindex $percm2 1] \ ]
    puts "xinv, inversion layer depth is $xinv"
    #Electron density /cm2
    set percm2 [KillChar [lindex $percm2 2] \ ]
    puts "inversion layer $var percm2 is $percm2"
    return $percm2
 }
 #example: set percm2 [InversionLayer Elec 1e15]

 proc GetTotElec {} {
    #sel z=log10(abs(Elec)+1.0)
    sel z=Elec
    set totelec [layers]
    set totelec [KillChar $totelec \{]
    set totelec [KillChar $totelec \}]
    set totelec [split $totelec \n];#split into lists at the newline
    set totelec [lindex $totelec 1];#returns the 1st element of the list (line w oxide)
    set totelec [split $totelec \t];#split into new list at tabs
    #inversion layer depth
    set mat [KillChar [lindex $totelec 3] \ ];#get 3rd element (material)
    set totelec [KillChar [lindex $totelec 2] \ ];# get 2nd element (integral)
    set totelec [expr log10(abs($totelec)+1.0)];# take log for better graphing
    puts "totelec in the $mat is $totelec"
    return $totelec
 }
 #example: set totelec [GetTotElec]