string_wave_1d_problem.h

Go to the documentation of this file.

/*
 * Copyright 2021 MusicScience37 (Kenta Kabashima)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
 
#include <cmath>
 
#include <Eigen/Core>
 
#include "num_collect/base/index_type.h"
#include "num_collect/constants/pi.h"
#include "num_collect/ode/evaluation_type.h"
#include "num_collect/util/assert.h"
 
namespace num_prob_collect::ode {
 
struct string_wave_1d_parameters {
public:
    double speed{1.0};
 
    num_collect::index_type num_points{101};  // NOLINT
 
    double length{1.0};
};
 
class string_wave_1d_problem {
public:
    using variable_type = Eigen::VectorXd;
 
    using scalar_type = double;
 
    static constexpr auto allowed_evaluations =
        num_collect::ode::evaluation_type{.diff_coeff = true};
 
    explicit string_wave_1d_problem(const string_wave_1d_parameters& params)
        : speed_(params.speed), num_points_(params.num_points) {
        NUM_COLLECT_ASSERT(params.num_points >= 3);
        points_ = variable_type::LinSpaced(num_points_, 0.0, params.length);
        diff_coeff_ = variable_type::Zero(num_points_ * 2);
    }
 
    void evaluate_on(scalar_type /*time*/, const variable_type& variable,
        num_collect::ode::evaluation_type /*evaluations*/) {
        const double dx = points_(1) - points_(0);
        // acceleration.
        diff_coeff_.segment(1, num_points_ - 2) = speed_ * speed_ / (dx * dx) *
            (variable.segment(num_points_ + 2, num_points_ - 2) -
                2.0  // NOLINT
                    * variable.segment(num_points_ + 1, num_points_ - 2) +
                variable.segment(num_points_, num_points_ - 2));
 
        // velocity.
        diff_coeff_.segment(num_points_, num_points_) =
            variable.segment(0, num_points_);
    }
 
    [[nodiscard]] auto diff_coeff() const noexcept -> const variable_type& {
        return diff_coeff_;
    }
 
    [[nodiscard]] auto points() const noexcept -> const variable_type& {
        return points_;
    }
 
private:
    double speed_;
 
    num_collect::index_type num_points_;
 
    variable_type points_;
 
    variable_type diff_coeff_;
};
 
class string_wave_1d_solution {
public:
    explicit string_wave_1d_solution(const string_wave_1d_parameters& params)
        : speed_(params.speed),
          length_(params.length),
          points_(Eigen::VectorXd::LinSpaced(
              params.num_points, 0.0, params.length)),
          solution_(Eigen::VectorXd::Zero(params.num_points * 2)) {}
 
    void evaluate_on(double time) {
        const num_collect::index_type num_points = points_.size();
 
        // velocity.
        solution_.segment(0, num_points) =
            (points_ * num_collect::constants::pi<double> / length_)
                .array()
                .sin() *
            (-num_collect::constants::pi<double> * speed_ / length_) *
            std::sin(
                time * num_collect::constants::pi<double> * speed_ / length_);
 
        // displacement.
        solution_.segment(num_points, num_points) =
            (points_ * num_collect::constants::pi<double> / length_)
                .array()
                .sin() *
            std::cos(
                time * num_collect::constants::pi<double> * speed_ / length_);
    }
 
    [[nodiscard]] auto solution() -> const Eigen::VectorXd& {
        return solution_;
    }
 
private:
    double speed_;
 
    double length_;
 
    Eigen::VectorXd points_;
 
    Eigen::VectorXd solution_;
};
 
}  // namespace num_prob_collect::ode