Author Topic: LDOS  (Read 4145 times)

0 Members and 1 Guest are viewing this topic.

Offline ziand

  • Heavy ATK user
  • ***
  • Posts: 78
  • Country: de
  • Reputation: 5
    • View Profile
LDOS
« on: January 20, 2012, 17:25 »
It seems there is no way to obtain the LDOS in ATK.
We have DOS, DDOS, and LDDOS.

Of course, one can create an ideal device and use the LDDOS but wouldn't it be easier to use normal BulkConfiguration and have a LDOS?

Offline kstokbro

  • Supreme ATK Wizard
  • *****
  • Posts: 392
  • Reputation: 13
    • View Profile
    • QuantumWise
Re: LDOS
« Reply #1 on: January 21, 2012, 16:27 »
Yes, this is correct, we will consider the ldos for bulkconfigurations for the 12.8 release.

You may construct the ldos by calculating bloch states and summing them up.



Offline ziand

  • Heavy ATK user
  • ***
  • Posts: 78
  • Country: de
  • Reputation: 5
    • View Profile
Re: LDOS
« Reply #2 on: February 10, 2012, 17:27 »
Yes, I think I know how to do that.

I want to calculate the LDOS for a finite piece of CNT.
I put it in a big bulkconfiguration with vacuum in A, B and C direction.
So, there is no periodicity and I only need 1 k-point.
Then I calculate the MolecularEnergySpectrum, which tells me the number of states.
Then I must calculate all those BlochStates.
Finally a need to sum their absolute values.

This brings me to the point of another feature:

ATK makes strong use of numpy. Lots of ATK-objects are grid-based data
which is stored in numpy-arrays internally.?
Right now, one can easily calculate sums from those grid-based objects
by just placing a "+" or a "-" in between. The result is another ATK-object
of the same kind. This is extremly convenient and one of the strength
of object oriented programming.

Now, wouldn't it be nice to have numpy operations available on
ATK-grid-objects? Like abs, conj, ** (power), ...

If this is not possible, then some important things like abs or conj could
be put into every grid-based object, as a method
(derivatives is already there...).

However, as I workaround I can evaluate the thing at every grid-point and
do whatever with that data. This is a bit slow and I can not save my stuff
to an ATK-nc file, afterwards.
 

Offline ziand

  • Heavy ATK user
  • ***
  • Posts: 78
  • Country: de
  • Reputation: 5
    • View Profile
Re: LDOS
« Reply #3 on: February 10, 2012, 18:30 »
About the LDOS from Bloch states procedure:
How should I select the energy?

There is the relation Bloch-state-quantum-number <--> energy eigenvalue.

Oh, by the way I think the first part of my previous post is wrong.
One should sum over k-point, and not energies! Right?

In my finite-CNT example, there is only one k-point, so the absolute
value of the bloch-states should be the LDOS at the energy which
corresponds to the selected quantum number. Right?

Then the above question stays:
Is it possible to select an energy e.g. in between two states?
I have a strong feeling that this should not be possible, as there
ARE NO STATES in between. It's a molecule!


The real thing that I want to do is the following:
I want do subtract the LDOS of a finite CNT from some another
LDOS that I got from a LDDOS (device) calculation.

With the above said, I need to get LDOS values of a finite CNT
at arbitrary energies (near the Fermi level (-2eV, ..., 2eV)).

Offline Nordland

  • QuantumATK Staff
  • Supreme ATK Wizard
  • *****
  • Posts: 812
  • Reputation: 18
    • View Profile
Re: LDOS
« Reply #4 on: February 10, 2012, 20:28 »
Yes, I think I know how to do that.
Now, wouldn't it be nice to have numpy operations available on
ATK-grid-objects? Like abs, conj, ** (power), ...

That is a good idea.

Offline Anders Blom

  • QuantumATK Staff
  • Supreme ATK Wizard
  • *****
  • Posts: 5030
  • Country: dk
  • Reputation: 85
    • View Profile
    • QuantumATK at Synopsys
Re: LDOS
« Reply #5 on: February 13, 2012, 10:36 »
About the LDOS for a finite system, I'm not sure that approach works. There is no k-point dependence, hence no Bloch states in the traditional sense, only molecular eigenstates. And these have fixed energies, so your DOS is a sequence of delta-functions.

You can always extract the pure data from an LDOS object by doing data=ldos.toArray(). Then you have a native numpy array and can do all manipulations you need, incl. abs, power, and so on. I think it might be hard to implement this functionality generally for all our objects since you get into some trouble with units etc.