dalerxli / a-dda Goto Github PK

Explain the transformation of the radiation forces due to the surrounding
medium in the manual. 

Implement convex hull algorithm into shape generator to enable much wider
variety of automatically generated shapes. The idea and sample code were
given by Roman Schuh.

Use weighting function for integration of scattered fields to obtain Csca
and g. Take into account at least the diffraction peak. This is similar to
what is currently done in DDSCAT.

Study different formulations for Cabs, especially for very large refractive
index. Also check, how cross sections should be calculated in the FCD
framework.

Implement general shapes like 'coated ellipsoid', 'boxsphere', 'spherebox'
with a lot of input parameters. It may be also implemented as a arbitrary
composition of basic shapes.

Implement saving of amplitude matrix (versus scattering angle) to file
(together with Mueller matrix).

Optimize accumulate function (parallel communication) when averaging over
alpha angle. Do all communication at once and do not use unnecessary memory
(Eplane <=> ampl_alpha).

Further develop the checkpoint system. Extend it to calculations of two
polarizations and orientation averaging. 

Add specific definition (with figures) of the used notation for Euler
angles in the manual.

Add timing (in standard timing regime) for MatVec function. It will help
further optimizations of FFT and related code.

Implement citation of the manual independently of the code, through e.g.
arxiv.org.

Implement certain parts of the code using MPI functions in FFTW 3.2 (3.3
alpha), either the whole 3D FFT transforms, or local and MPI transpose
operations.

Ensure that when -prognosis option is used, minimum memory is allocated in
make_particle(). Or think of some way to avoid memory allocation
altogether, i.e. implementing something like 'approximate quick prognosis'.

Implement multi-grid DDA, according to the ideas of Vitezslav Karasek, for
simulation of clusters of particles, which are at considerable distances
from each other.

Completely rewrite calculation of radiation forces using FFT. Add its
memory requirements to -prognose estimates, and perform other integration
into the code.

Reformulate orientation averaging so that only one incident polarization
per orientation is simulated.

Save more information about the shape, when using -save_geom.

Implement new iterative solvers, e.g. 2-term QMR (its complex symmetric
variant). Should improve performance for very slow convergence.

Implement convenient simulation of spectrum, either inside of ADDA, or with
a separate script. Possibly optimize calculation by simultaneous solving
for many wavelength values in one iterative sequence  (should be especially
relevant in case of Rayleigh particles).

Implement specifying incident propagation direction by two angles instead
of Cartesian coordinates of the vector of incidence.

Several possible ways to optimize MPI part of the code: 1) use one buffer
for all MPI communications; 2) possibly use MPI_ALLTOALL and 'derived
datatypes' for block_transpose; 3) use 'persistent communication requests'
for repeated communications.

Optimize ADDA for shared memory hardware (e.g. multi-core processors),
using standard MPI functions and/or OpenMP directives.

Possibly revise the definition of box in 'box' and 'spherebox' shapes.
Think about different alternatives.

Think of a convenient way to calculate near field in a number of points or
on a grid around the particle. Possibly implement calculation of the
B-field together with E-field.

Add command line option to choose the whole formulation (like FCD, SO, LDR,
etc.), which will be equivalent to a combination of options -pol, -int and
-scat. However, the possibility to use old options or a combination of new
and old ones should remain.

Implement calculation of scattering for the 2D grid of scattering angles
(and asymmetry parameter) in combination with orientation averaging. This
can be useful when orientation is not completely random.

Further optimize calculation of the scattered field, according to the ideas
of R. Scott Brock. In parallel mode distribute internal fields evenly
between processors (MPI_ALLTOALLV). 

Add description of features (capabilities) in the manual and on the web site.

Implement SOF (Born series) as a iterative solver (with controlled number
of iterations). It can be used, e.g., to simulate RDG results.

Implement orientation averaging using quadrature over sphere surface,
according to ideas of Antti Penttila.

Add a description in the appendix of the manual, how to add new incident
field option in the code. Also add corresponding comments to the code. Do
the same for adding command line options.

Implement reading of initial field for iterative solver and incident
electric field from file. This will enable any incident field and allow
more flexibility in complex simulations. For instance, to adaptively
decrease dipole size reusing previous results.

Implement binary format for shape files, which can save space tremendously
for homogeneous particles.

Make memory accounting more accurate, include non-major contributions and
take into account dynamic allocation/deallocation.

Compute the total communication time during the iterative solver, since the
last iteration is not always representative.

Analyze dipoles with refractive index equal to unity and make them void in
the beginning of the program. Also find out why the simulation fails now
when m=1 is specified; probably somewhere there is division over zero.

Rewrite implementation of the -jagged option, so everything is done in the
end of make_particle(). Then everything else will be automatically
compatible with it. Also optimize the main cycle in make_particle.

Optimize storage of D matrix to use less memory (at least in sequential mode).

Check calculation of residual inside the iterative solvers. Maybe it would
be more accurate to recalculate it at the end.

Implement simulation for single given incident polarization (complex
amplitude). It will cut down simulation time twice for certain applications.

Implement Van der Mee & Hovenier test on the Mueller matrix. Probably makes
real sense only for the results of orientation averaging.

Implement continuous polarizability (not discrete values, as now), change
-read format accordingly. Possibly implement full tensor of polarizability.
This will open way to many new features, in particular Weighted Discretization.

Implement optimizations based on the analysis of the shape (position of
real dipoles on the grid) to decrease tests and indirect indexing in
MatVec, CalcField, etc. It is not clear, how exactly to do it.

Try to avoid overflow of 'clock' function when run in a sequential mode.

Implement special Rayleigh mode, which enables some simplifications (like
using CG iterative solver and calculating only total polarizability
tensor). Use additional symmetries of the particle (rotation around y and x
axes by 90 degrees). See ideas of Budko & Samokhin (2005) for iterative
solvers. Also think, how to calculate the total static polarizability
tensor of the particle, using three different incident polarizations.

Mention in the manual and/or on the web site the current state-of-the-art
in DDA vs. FDTD comparison. Reference the recent Optics Express paper.

Optimize arithmetic operations in the MatVec function, especially the
middle one (Arithm3).

Implement automatic testing of releases with a wide range of command line
options. Results of simulations should be automatically parsed and compared
to fixed references. This should decrease the chance of introducing new
bugs into old parts/features of the code during further development.

Further develop SO formulation, bring it out of the development phase.

Implement all possible polarization prescription, at least those that are
easy to do (DGF, LAK, a1-term, etc.). Think about other existing
possibilities for -scat and -int options.