TimeEvolutionOperator

This is an introduction to the TimeEvolutionOperator class. We write a small overarching summary of the class where we define the algorithm/equation/structure reasoning for having this class or where it fits with the rest of the code.

digraph { "ConvolutionOperator" -> "TimeEvolutionOperator" }
template<int D>
class TimeEvolutionOperator : public mrcpp::ConvolutionOperator<D>

Semigroup of the free-particle Schrodinger equation.

Represents the semigroup \( \exp \left( i t \partial_x^2 \right) . \) Matrix elements (actual operator tree) of the operator can be obtained by calling getComponentCplx(0, 0). In \( D \) dimensions the same tree acts in every direction, giving \( \exp \left( i t \Delta \right) = \bigotimes_{d=1}^D \exp \left( i t \partial_{x_d}^2 \right) \).

The world can be any non-periodic BoundingBox with the same scaling factor in every direction, for example \( [-L, L]^D \). The time has units of length squared in the box coordinates: for \( H = -\frac 12 \Delta \) a step \( \Delta t \) is time \( \Delta t / 2 \).

Note

Implemented for Legendre scaling functions only.

Public Functions

TimeEvolutionOperator(const MultiResolutionAnalysis<D> &mra, double prec, double time, int finest_scale = Adaptive, int max_Jpower = 30)

Semigroup \( \exp(i t \partial_x^2) \).

An adaptive constructor for TimeEvolutionOperator class.

Constructs the complete complex Schrodinger semigroup at a given time moment.

Note

Applying this to a real FunctionTree aborts; project the input as ComplexDouble first, or let the CompFunction overload promote it.

Note

For technical reasons the operator tree is constructed no deeper than \( N = 18 \) scales below the root scale.

Parameters:
  • finest_scale – [in] uniform refinement down to this scale; Adaptive (the default) refines adaptively.

  • max_Jpower – [in] number of power integrals used in the series expansion. The series is only used for blocks where the kernel’s phase turns by at most one radian per box; faster blocks are integrated directly, so the default leaves big margin.

  • mra – [in] MRA.

  • prec – [in] precision.

  • time – [in] the time moment (step).

TimeEvolutionOperator(const MultiResolutionAnalysis<D> &mra, double prec, double time, bool imaginary, int max_Jpower = 30) = delete

Rejects the legacy signatures carrying the removed imaginary argument.

inline int isreal() const

Whether the operator stores real coefficients.

Note

Reports the storage type, not whether the imaginary part vanishes.

inline int iscomplex() const

Whether the operator stores complex coefficients.

Note

Reports the storage type, not whether any imaginary part is set.

OperatorTree<ComplexDouble> &getComponentCplx(int i, int d)

Separable term i in direction d of a complex kernel.

Note

Aborts for a real operator; guard with iscomplex().

const BandWidth &getBandWidth(int i, int d) const

Band width of separable term i in direction d.

Reads from whichever expansion is populated, so callers that only need the band do not have to know the scalar.

inline std::array<OperatorTree<double>*, D> &operator[](int i)

Note

Real expansions only; aborts on a complex operator.

Public Static Attributes

static constexpr int Adaptive = std::numeric_limits<int>::min()

Pass as finest_scale to refine adaptively instead of uniformly. It lies below every scale, since scales are negative on large worlds.

Protected Functions

void initialize(double time, int finest_scale, int max_Jpower)

Creates the complex operator.

Uniform down to finest scale.

void initialize(double time, int max_Jpower)

Creates the complex operator.

Adaptive down to \( N = 18 \) scales below the root scale.

void initializeSemiUniformly(double time, int max_Jpower)

Creates the operator (in progress)

Tree construction starts uniformly and then continues adaptively.

Note

This method is not ready for use and should not be used (in progress).