Package pulse.problem.schemes

Class DifferenceScheme

  • All Implemented Interfaces:
    Serializable, Descriptive, Reflexive
    Direct Known Subclasses:
    ADIScheme, OneDimensionalScheme
    public abstract class DifferenceScheme
extends PropertyHolder
implements Reflexive
    A DifferenceScheme is an abstract class that declares general methods for converting a Problem to a set of algebraic operations on a Grid. The Grid object defines the time and coordinate partitioning, adjusted to ensure a stable or conditionally-stable behaviour of the solution. The Grid is also used to define a DiscretePulse function.
    See Also:
    Grid, DiscretePulse, Serialized Form

    • Constructor Detail

      • DifferenceScheme

        protected DifferenceScheme()
        A constructor which merely sets the time limit to its default value.

      • DifferenceScheme

        protected DifferenceScheme​(NumericProperty timeLimit)
        A constructor for setting the time limit to a pre-set value.
        Parameters:
        timeLimit - the calculation time limit

    • Method Detail

      • copyFrom

        public void copyFrom​(DifferenceScheme df)
        Copies the Grid and timeLimit from df.
        Parameters:
        df - the DifferenceScheme to copy from

      • prepare

        protected void prepare​(Problem problem)
                throws SolverException

        Contains preparatory steps to ensure smooth running of the solver.This includes creating a DiscretePulseobject and adjusting the grid of this scheme to match the DiscretePulsecreated for this problem Finally, a heating curve is cleared from the previously calculated values.

        All subclasses of DifferenceScheme should override and explicitly call this superclass method where appropriate.

        Parameters:
        problem - the heat problem to be solved
        Throws:
        SolverException

      • scaleSolution

        public void scaleSolution​(Problem problem)

      • pulse

        public double pulse​(int m)

      • prepareStep

        public void prepareStep​(int m)
        Do preparatory calculations that depend only on the time variable, e.g., calculate the pulse power.
        Parameters:
        m - the time step number

      • normalOperation

        public boolean normalOperation()

      • listedKeywords

        public Set<NumericPropertyKeyword> listedKeywords()
        The superclass only lists the TIME_LIMIT property.
        Overrides:
        listedKeywords in class PropertyHolder
        Returns:
        a set of NumericPropertyKeyword instances, which have been explicitly marked as a listed parameter for this PropertyHolder.

      • getDiscretePulse

        public final DiscretePulse getDiscretePulse()
        Gets the discrete representation of Pulse on the Grid.
        Returns:
        the discrete pulse
        See Also:
        Pulse

      • getGrid

        public final Grid getGrid()
        Gets the Grid object defining partioning used in this DifferenceScheme
        Returns:
        the grid

      • setGrid

        public final void setGrid​(Grid grid)
        Sets the grid and adopts it as its child.
        Parameters:
        grid - the grid

      • getTimeInterval

        public final int getTimeInterval()
        The time interval is the number of discrete timesteps that will be discarded when storing the resulting solution into a HeatingCurve object, thus ensuring that only a limited set of points is stored.
        Returns:
        the time interval

      • setTimeInterval

        public final void setTimeInterval​(int timeInterval)
        Sets the time interval to the argument of this method.
        Parameters:
        timeInterval - a positive integer.

      • areDetailsHidden

        public final boolean areDetailsHidden()
        If true, Lets the UI know that the user only wants to have the most important properties displayed. Otherwise this will signal all properties need to be displayed.
        Overrides:
        areDetailsHidden in class PropertyHolder
        Returns:
        true if the auto-adjustable numeric properties need to stay hidden, false otherwise.

      • setDetailsHidden

        public static final void setDetailsHidden​(boolean b)
        Changes the policy of displaying a detailed information about this scheme.
        Parameters:
        b - a boolean.

      • getTimeLimit

        public final NumericProperty getTimeLimit()
        The time limit (in whatever units this DifferenceScheme uses to process the solution), which serves as the ultimate breakpoint for the calculations.
        Returns:
        the NumericProperty with the type TIME_LIMIT
        See Also:
        NumericPropertyKeyword

      • getCurrentPulseValue

        public double getCurrentPulseValue()

      • setTimeLimit

        public final void setTimeLimit​(NumericProperty timeLimit)
        Sets the time limit (in units defined by the corresponding NumericProperty), which serves as the breakpoint for the calculations.
        Parameters:
        timeLimit - the NumericProperty with the type TIME_LIMIT
        See Also:
        NumericPropertyKeyword

      • set

        public void set​(NumericPropertyKeyword type,
                NumericProperty property)
        Description copied from class: Accessible

        An abstract method, which must be overriden to gain access over setting the values of all relevant (selected by the programmer) NumericProperties in subclasses of Accessible. Typically this involves a switch statement that goes through the different options for the type and invokes different set(...) methods to update the matching NumericProperty with property.

        Specified by:
        set in class Accessible
        Parameters:
        type - the type, which must be equal by definition to property.getType().
        property - the property, which contains new information.

      • signal

        public abstract double signal()

      • clearArrays

        public abstract void clearArrays()

      • domain

        public abstract Class<? extends Problem>[] domain()
        Retrieves all problem statements that can be solved with this implementation of the difference scheme.
        Returns:
        an array containing subclasses of the Problem class which can be used as input for this difference scheme.

      • copy

        public abstract DifferenceScheme copy()
        Creates a DifferenceScheme, which is an exact copy of this object.
        Returns:
        an exact copy of this DifferenceScheme.