CompCondMat

DCOMP blog

2011-04-14T17:04:00.000-07:00

The Division of Computational Physics of the American Physical Society has got a blog on blogspot. Check it out here.

March Meeting: where is computational physics going?

2011-03-27T22:11:00.000-07:00

At the focus sessions about computational physics at the APS March Meeting in Dallas, challenges for the computational physics (or computational science in general) community have been identified. Probably the most important issue is to further develop education in computer related sciences and to make it standard in undergraduate curricula.
Then there were more technical things such as algorithm design having to pay more attention to keep parallel computing in mind, and making programs robust against data loss (e.g. failure of a subset of computing nodes).
Further issues came up in the discussions after the talks, in my opinion all more or less related to each other. It still seems to be necessary to advocate the relevance of computational physics. While this is not a problem in condensed matter physics (in my experience at least), this was reported to be different for parts of the atomic physics community.
Another important issue was addressed towards the end of these sessions: should a researcher doing computational physics research be able to write the code on her/his own? Or would it (even at the level of a principle investigator) be enough to be able to use a code? I think that there should be a balance between writing codes and actually producing scientific output. I think it is optimal if the PI knows how the codes work so she/he could supervise interested students in implementing/extending codes. At the student level just using codes might in some cases be enough, but ideally, I think, there should be people able to work on the codes in each group as well. The hopefully resulting collaboration within these groups would help avoiding computational physics codes misconceptionally be regarded as black boxes, and it could on the other hand also reduce the problems of programmers playing around with their codes.
In my opinion it would be a problem for the computational physics community, if the usage and development of codes would be separated further. The groups simply using codes will be the more successful ones (due to higher publication output), but chances of education on how things are calculated and in some sense even on what is calculated are missed (necessarily reducing the quality of the research). Groups mainly focusing on code development will miss out on publications (unless the development of codes would be given more importance and even be considered as scientific output, i.e. there would be more journals like Computer Physics Communications - how about a physical society-based journal?). And their students might lack education on how to do scientific work or communicate results. I thus believe that, besides asking experts from e.g. applied mathematics for help, keeping or bringing back together usage and development of codes will be of benefit for both parts.

Del.icio.us links for stuff built from meccano

2010-12-19T11:05:00.000-08:00

Delicious/quasinewton/meccano

Demonstration of Neil Fraser's "don't try this at home" java lamp centrifuge:

Del.icio.us links for Dilbert

2010-12-18T01:47:00.000-08:00

Delicious/quasinewton/Dilbert

"Proton on a string"

2010-09-30T13:27:00.000-07:00

In the preprint "Modified string method for finding minimum energy path" (arXiv:1009.5612), Amit Samanta and Weinan E describe a method for finding so-called minimum energy paths (MEP). These paths are the ones with most statistical weight wrt. a transition in configuration space. This could e.g. be a diffusional process, which is shown below for proton conduction in SrTiO₃ (Sr, Ti, O and H depicted as green, gray, red and white spheres, respectively; the potential energy surface has been calculated using the Quantum Espresso package), see the preprint for other examples.

I have compared their presented modification of the string method to the nudged elastic band method (NEB). Both methods sample the path using a finite number of images. An initial guess for the path is optimized by gradient following. The two methods differ in how the sliding down of intermediate images from barriers is prevented. For the NEB, this is achieved by introducing virtual spring forces, keeping the images apart. For the string method, the path is iteratively re-parametrized such that the path is evenly sampled.
Both methods perform similarly well. Below are shown the potential energies for MEPs obtained using the string and NEB methods for the above proton diffusion path in SrTiO₃, respectively:

The residual gradients in the initial and final configurations seem to be a little too large, therefore the NEB path shows the tendency to have minima away from these configurations. The string method, which is implemented here to fulfill Eq. 6 of the preprint at each optimization step, is more stable against this problem (in the case of the NEB, intermediate configurations at ~0.5 and ~4 Å should be relaxed separately as new boundary configurations).
What is interesting is that the new string method shows a slightly better convergence of the MEP (here optimized using Broyden's method with rank one Quasi-Newton updates):

Instead of plain re-parametrization at each step, the more sophisticated schemes outlined in the preprint might even yield better convergence. Despite the simplicity of what was implemented here, this seems to be basically as good as the NEB method.

Random numbers out of vacuum

2010-09-07T09:40:00.000-07:00

In a letter to Nature Photonics Gabriel et al. have generated truly random numbers (as opposed to pseudo random numbers) by measuring continuous vacuum state quadratures (i.e. E-field noise) in a homodyne setup. Random number data sets can be downloaded from their website: http://mpl.mpg.de/mpf/php/abteilung1/index.php?lang=de&show=workgroups&in=qiv&and=&page=qiv/quantumbits. They are even planning on a random number live stream you can directly feed into your Quantum Monte Carlo calculations.

"Backfolding" of Fermi surfaces revisited

2010-03-18T20:16:00.001-07:00

Folding the paper model up is easiest beginning from the bottom of the sketch below. Which noble metal does this Fermi surface belong to?

|→ Quasiparticles

2010-01-02T10:50:00.000-08:00

Quasiparticle models allow for a solution of certain many-particle problems and may also provide descriptive pictures. Examples in solid state physics are

composite Fermions with a mean field approximation related to the attached flux
effective-mass Hamiltonians, where the energetic dispersion is reproduced
Kohn-Sham Hamiltonians, where an effective potential is adjusted such that a given density is obtained (self-consistently)

In the case of non-interacting quasiparticles, an efficient solution of the corresponding many-particle problem is possible. Furthermore, infinite interaction strength can be considered instead (or in addition to zero interaction strength in terms of interpolation; see e.g. Seidl, Perdew, Kurth, PRL 84, 5070 (2000)). Although Kohn-Shamions are often over-interpreted as single electrons, I'd still say that they are neat quasiparticles since it's the best you can generally do with a single Slater determinant. Would be cool to have solvable, not low-dimensional models for Coulomb systems at finite interaction strength (not only for a KS Hamiltonian). Are there any?

Really awesome is/would be the emergence of a Fermi liquid from the Anti-de-Sitter/Conformal Field Theory correspondence — here, quasiparticle shape and position in the spectral function are approximately reproduced [Cubrovic, Zaanen, Schalm, arXiv:0904.1993, Science 325, 439 (2009)] (in the AdS/CFT correspondence itself, the product of string coupling and number of D-branes is kept fixed — quasi² ...). [For composite Fermions ↔ gravity, have a look at Bak, Rey, arXiv:0912.0939.]

Quantum simulation

2009-10-03T03:51:00.000-07:00

In a quantum simulation, the evolution of a quantum many-body system is 'emulated' by mapping the Hamiltonian onto the one of a real system or by encoding in qubits [for a review see Buluta and Nori, Science 326, 108 (2009)]. This will be particularly important if the exponentially growing computational complexity does not allow for a simulation on a classical computer.
This will be easier to implement than systems for quantum computation, since smaller systems and lower accuracies would suffice, and decoherence could in some cases even be taken advantage of for the simulation of open systems.
There is still something that classical computational physicists and their computers could learn from the field of quantum computing/simulation: the development of classical algorithms for simulation based on ideas from quantum information science (see e.g. Chap. 5 in R. Orus' PhD thesis [link]).

Imaginary time projection method for construction of localized basis sets

2009-07-31T02:39:00.000-07:00

In the preprint arXiv:0907.5053v1, the authors Zhou and Ceperley present an efficient method to construct a localized basis set for a Hubbard lattice model of bosonic atoms in a disordered potential at a given instance of disorder. This is achieved by a projection technique based on propagation in imaginary time, which is related to diffusion processes of the atoms.

Apollo 11 code published online

2009-07-23T12:39:00.000-07:00

Parts of the code running on Apollo 11's control system have been published on Google code, based on the transcription of scanned images of the assembler source code from the MIT Museum. The codes can be run on an open source Apollo guidance computer emulator.

FPGAs solve N=26 queens problem

2009-07-21T05:22:00.000-07:00

While NQueens@Home is still working on it, the Queens@TUD project has solved the N=26 queens problem, that is, in how many different ways 26 queens can be placed on a chessboard without the possibility of capture among them. The solution is 22,317,699,616,364,044. Are local, "uncrowded" solutions faster after all? ;)

Games motivating human computing power

2009-07-18T16:24:00.000-07:00

Tasks like image recognition can generally not be reliably performed by computers yet, but for humans this is relatively easy. While I would say that the scope of computational physics essentially involves problems that are too complex to be solved by hand, there are problems where intuition will help finding a solution instead of barely relying on e.g. brute force computational-only approaches, i.e. the road from theory(thinking/modeling) to computational physics would be extended once more by cognitive power.

In the following I've listed three projects in the order I've come across them, each of them one step closer to the use of parallel human computing power in the field of computational condensed matter physics.

Read on

In this first video, Luis von Ahn illustrates how a large crowd can be motivated using "games with a purpose" to e.g. label images or to build up common-sense facts databases.

This video is about the game "Foldit", in which the score of a player is based on the optimality of a interactively folded protein.

In the following video, the spectral game (link; journal ref) is introduced.

It is intended as an educational game, but I guess a similar game could aim at predicting crystal structures by allowing the player to select a space group and to choose the sites of the elements of a given formula - the score would be based on how well e.g. powder diffraction patterns are reproduced (however, I have to admit that this wouldn't be a game I'd like to play). More fun could be the interactive construction of candidate structures by "mating" given starting cells (mixing slices etc.), in the spirit of genetic algorithm approaches to the crystal symmetry prediction problem.

Since "knowledge/intuition-based image processing" is something where games are very useful, it would be nice if "less visual" problems could be mapped onto kind of a 2D-image analysis problem.

3D layered FQHE

2009-07-11T05:04:00.000-07:00

Read on

Simulation of a 3D FQHE system. Suggested reading:

Fractional charges fly between planes
Burnell, Sondhi
Physics 2, 49 (2009)
http://physics.aps.org/articles/v2/49

Gapless layered three-dimensional fractional quantum Hall states
Levin, Fisher
Phys. Rev. B 79, 235315 (2009)
http://link.aps.org/doi/10.1103/PhysRevB.79.235315

Bismuth in strong magnetic fields: Unconventional Zeeman coupling and correlation effects
Alicea, Balents
Phys. Rev. B 79, 241101(R) (2009)
http://link.aps.org/doi/10.1103/PhysRevB.79.241101

What’s computational physics about?

2009-06-29T09:21:00.001-07:00

Is it a subfield of theory? What about - uhmm - “numerical experiments” (if there’s something like that)?

One could consider numerical simulation a third paradigm of science besides theory and experiment (see e.g. this link).
The term “numerical experiment”, however, would suggest a black box concept, i.e. you feed some input into the code and get numbers out, but don’t necessarily understand how and why it works and therefore not even if the output means anything.
So I would prefer the term “simulation” and make computational physics a part of theory and apply it to problems which are too complex to be solved by hand. Along this line scientific computing can aim at providing new “tools of discovery” of complex phenomena.

What do you think “scientific computing” is about and do you think it is important at all to decide which field it belongs to?

Bandstructure code from 1972

2009-06-25T03:30:00.000-07:00

Electronic bandstructure of cubic YZn calculated with an APW code from the early 70's.

Are there still source codes of other old bandstructure programs available?

See further details about how to compile and use the code on nowadays hardware below.

In 1972, Hoffstein, Ray, and Belakhovsky have published a symmetrized augmented planewave code http://dx.doi.org/10.1016/0010-4655(72)90098-7 (Comput. Phys. Commun. 4 361 (1972)), which I've used to calculate the data shown in the figure above. Neither source nor binary must be distributed. You need access to the Computer Physics Communications Program Library to get the source code (tip: search for the authors to find the archive).

The program was written in Fortran IV (≈ Fortran 66) and the file you download is a punch code conversion containing the command line for the compilation, the source code, what is fed to standard input...
To extract the Fortran code and the input data run:

zcat acmj_v1_0.gz | tail +10 | head -1224 >sapw.f
zcat acmj_v1_0.gz | tail +1308 | head -313 >>sapw.f
zcat acmj_v1_0.gz | tail +1622 | head -506 >inph

We've skipped a few lines of the source code, which back in the days served for the calculation of a float encoded in a four character string in a special (but simple) way. The replacement of this routine for other hardware was actually worth a second publication by de Hosson in 1975 (http://dx.doi.org/10.1016/0010-4655(75)90091-0) ...

We'll take advantage of something else that was developed in 1972 - C - to implement this simple conversion:

/* conv.c */

double conv_(char *x)
{
    double sign = 1., c = 0., d;
    int i;

    for(i=0, d=1000.; i<4; i++, d/=10.) {
       switch(x[i]) {
       case '+':
           sign = 1.;
           break;
       case '-':
           sign = -1.;
           break;
       case 'A':
           c += sign * d * 0.86602540378;
           break;
       case 'B':
           c += sign * d * 0.5;
           break;
       case 'C':
           c += sign * d * 1.5;
       case 32:
           break;
       default:
           c += ((double) (x[i]-48)) * sign * d;
       }
    }

    return c;
}

Phew, what a masterpiece ;)

Compile with:

gcc -O2 -c conv.c
gfortran -O2 -fdefault-real-8 -o sapw sapw.f conv.o

The following python script can be used to calculate the dispersion from Γ to R:

from os import system,popen

e = []
for i in range(9):
  e.append({})

for s in (-2.0,-1.8,-1.5,-1.2,-1.0,-0.7,-0.5,-0.2,0.4,0.6,0.8):
  for i in range(9):
    k = float(i)/10.+0.1

    system('cat inph >inp')
    f = open('inp','a')
    print >>f,'       %g       %g       %g' % (k,k,k)
    print >>f,' -4  3  1  1  1 R 15 BANDS\n      %g     0.05   50' %s
    f.close()

    p = popen("./sapw <inp | grep EIGENVA | awk '{print $3}'")
    a = p.readline().strip()
    p.close()
    if len(a)>0:
      e[i][a] = 1

for i in range(9):
  k = float(i)/10.+0.1
  q = e[i].keys()
  q.sort()
  for a in q:
    print k, float(a)*2.0

You spin my subspace right round... - direct minimization in DFT for metallic systems

2009-06-19T12:07:00.000-07:00

The article

Direct minimization technique for metals in density functional theory
Freysoldt, Boeck, Neugebauer
Phys. Rev. B 79, 241103(R) (2009)
http://link.aps.org/doi/10.1103/PhysRevB.79.241103

describes a method for the direct minimization of the expansion coefficients of the Kohn-Sham orbitals in a density functional theory scheme with simultaneous and consistent updates of occupation numbers and subspace rotations.
This extension to previous approaches allowed the authors to perform fast direct-minimization-DFT calculations for metallic systems (the convergence of which depends sensitively on changes in the Kohn-Sham Fermi surface during the iterations).
Since the KS orbitals have to be orthonormalized, the asymptotic complexity, however, is O(N³), i.e. the same as for self-consistent, iterative diagonalization of the KS Hamiltonian or any other KS orbital-based approach.