computer physics

import java.util.ArrayList;

public class EulerMethod {

    /** Проекция на ось икс */
    private static final int AXIS_X_PROJECTION = 0;
    /** Проекция на ось игрек */
    private static final int AXIS_Y_PROJECTION = 1;
    /** Ось икс */
    private static final int X = 0;
    /** Ось игрек */
    private static final int Y = 1;

    public static void main(String[] args) {
        firstSolve();
    }

    /** Решение третьей задачи */
    private static void thirdSolve() {
        for (double densityBody : new double[] {2700, 7800, 19000}) {
            Coefficients coefficients =
                    new Coefficients(densityBody, 9.81, 0.000018, 0.0001, 0.47, 1.29, .0001);
            double angle = Math.toRadians(40);
            double velocity = 20;
            Parameters[] flight = calculateFlight(coefficients, angle, velocity);
            System.out.println("Density body: " + densityBody);
            System.out.println("Range of flight: " + rangeOfFlight(flight));
            System.out.println("Max height: " + maxHeight(flight));
            System.out.println("===========================================");
        }
    }

    /** Решение второй задачи */
    private static void secondSolve(){
        for (double velocity : new double[] {10, 20 ,100}) {
            Coefficients coefficients =
                    new Coefficients(2700, 9.81, 0.000018, 0.0001, 0.47, 1.29, .0001);
            double angle = Math.toRadians(40);
            Parameters[] flight = calculateFlight(coefficients, angle, velocity);
            System.out.println("Velocity: " + velocity);
            System.out.println("Range of flight: " + rangeOfFlight(flight));
            System.out.println("Max height: " + maxHeight(flight));
            System.out.println("===========================================");
        }
    }

    /** Решение первой задачи */
    private static void firstSolve() {
        double max = -1;
        double angleMax = -1;
        for (double i = 1; i <= 90; i+=.1) {

            Coefficients coefficients =
                    new Coefficients(2700, 9.81, 0.000018, 0.0001, 0.47, 1.29, .0001);
            double angle = Math.toRadians(i);
            double velocity = 20;
            Parameters[] flight = calculateFlight(coefficients, angle, velocity);
            double range = rangeOfFlight(flight);
            System.out.println(i + ": " + range);
            if (rangeOfFlight(flight) > max){
                max = range;
                angleMax = i;
            }
        }
        System.out.println("Maximum: " + angleMax);
    }

    /**
     * Расчет дальности полета
     * @param flight параметры тела через время index после начала полета
     * @return дальность
     */
    private static double rangeOfFlight(Parameters[] flight) {
        return flight[flight.length - 1].coordinates[X] - flight[0].coordinates[X];
    }

    /**
     * Расчет максимальной высоты полета
     * @param flight параметры тела через время index после начала полета
     * @return максимальная высота
     */
    private static double maxHeight(Parameters[] flight) {
        double max = Double.NEGATIVE_INFINITY;
        for (Parameters parameters : flight) {
            max = Math.max(max, parameters.coordinates[Y]);
        }
        return max;
    }

    /**
     * Просчитывает параметры тела во всех точках полета
     * @param coefficients коэффициенты
     * @param angle угол броска
     * @param initialVelocity начальная скорость
     * @return параметры тела через вермя index после начала полета
     */
    private static Parameters[] calculateFlight(Coefficients coefficients, double angle, double initialVelocity) {
        Parameters initialParameters = new Parameters(
                new double[]{initialVelocity * Math.cos(angle), initialVelocity * Math.sin(angle)},
                new double[]{0, 0});
        ArrayList<Parameters> parametersList = new ArrayList<>();

        Parameters parameters = initialParameters;

        do {
            parametersList.add(new Parameters(parameters));
            parameters = calculateIteration(coefficients, parameters);
        } while (parameters.coordinates[Y] != 0);

        return parametersList.toArray(new Parameters[0]);
    }

    /**
     * Получает изначальные параметры тела, и просчитывает его параметры через единицу времени
     * @param coefficients коэффициенты
     * @param parameters изначальные параметры тела
     * @return новые параметры тела
     */
    private static Parameters calculateIteration(Coefficients coefficients, Parameters parameters) {
        Parameters newParameters = new Parameters();
        double velocityVectorModule =
                moduleOfVector(parameters.velocity[AXIS_X_PROJECTION], parameters.velocity[AXIS_Y_PROJECTION]);

        newParameters.velocity[AXIS_X_PROJECTION] = parameters.velocity[AXIS_X_PROJECTION] + coefficients.tau *
                (-coefficients.alpha1 * parameters.velocity[AXIS_X_PROJECTION] - coefficients.alpha2 *
                velocityVectorModule * parameters.velocity[AXIS_X_PROJECTION]);

        newParameters.velocity[AXIS_Y_PROJECTION] = parameters.velocity[AXIS_Y_PROJECTION] + coefficients.tau *
                (-coefficients.gravity - coefficients.alpha1 *
                parameters.velocity[AXIS_Y_PROJECTION] - coefficients.alpha2 *
                velocityVectorModule * parameters.velocity[AXIS_X_PROJECTION]);

        newParameters.coordinates[X] = parameters.coordinates[X] + coefficients.tau * parameters.velocity[AXIS_X_PROJECTION];
        newParameters.coordinates[Y] = parameters.coordinates[Y] + coefficients.tau * parameters.velocity[AXIS_Y_PROJECTION];

        if (newParameters.coordinates[Y] < 0)
            newParameters.coordinates[Y] = 0;

        return newParameters;
    }

    /**
     * Считает модуль вектора
     * @param x коориднаты вектора
     * @param y координаты вектора
     * @return длина вектора
     */
    private static double moduleOfVector(double x, double y) {
        return Math.sqrt(x * x + y * y);
    }

    /** Класс параметров тела. Содержит все данные от теле в данный момент времени */
    private static class Parameters {
        /** Проекция скорости тела. Если index == 0 - проекция на ось X. Если index == 1 - проекция на ось Y */
        private double velocity[];
        /** Координаты тела. Если index == 0 - X. Если index == 1 - Y */
        private double coordinates[];

        /**
         * Конструктор
         * @param velocity проекции скорости
         * @param coordinates координаты
         */
        Parameters(double[] velocity, double[] coordinates) {
            this.velocity = velocity.clone();
            this.coordinates = coordinates.clone();
        }

        /**
         * Конструктор
         * @param parameters параметры
         */
        Parameters(Parameters parameters) {
            velocity = parameters.velocity.clone();
            coordinates = parameters.coordinates.clone();
        }

        /**
         * Конструктор пустых параметров тела
         */
        Parameters() {
            velocity = new double[2];
            coordinates = new double[2];
        }

    }

    /**
     * Коэффициенты (константы). Параметры которые не изменяются во время полета.
     */
    private static class Coefficients {
        /** Масса тела */
        double mass;
        /** Ускорение свободного падения */
        double gravity;
        /** Динамическая вязкость среды */
        double viscosity;
        /** Площадь поперечного сечения */
        double square;
        /** Коэффициент лобового сопротивления */
        double drag;
        /** Плотность среды */
        double density;
        /** Единица времени. Обычно короткий и неделимый промежуток времени */
        double tau;

        /** Объединения констант для упрощения формул */
        double alpha1;
        double alpha2;

        /** Конструктор */
        Coefficients(double densityBody, double gravity, double viscosity, double square, double drag, double densityMedium, double tau) {
            //Расчет массы через площадь поперечного сечения и плотность
            this.mass = densityBody * 4 / 3 * Math.PI * Math.pow(square / Math.PI, 1.5);
            this.gravity = gravity;
            this.viscosity = viscosity;
            this.square = square;
            this.drag = drag;
            this.density = densityMedium;
            this.tau = tau;

            //расчет альфа
            alpha1 = 6 * viscosity * Math.sqrt(Math.PI * square) / mass;
            alpha2 = drag * square * density / (2 * mass);
        }
    }
}