fault.h

Go to the documentation of this file.

/*
  Copyright (C) 2018-2024 by the authors of the World Builder code.

  This file is part of the World Builder.

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published
   by the Free Software Foundation, either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License
   along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

#ifndef WORLD_BUILDER_FEATURES_FAULT_H
#define WORLD_BUILDER_FEATURES_FAULT_H


#include "world_builder/features/fault_models/composition/interface.h"
#include "world_builder/features/fault_models/grains/interface.h"
#include "world_builder/features/fault_models/temperature/interface.h"
#include "world_builder/features/fault_models/velocity/interface.h"
#include "world_builder/objects/segment.h"
#include "world_builder/bounding_box.h"
#include "world_builder/objects/distance_from_surface.h"


namespace WorldBuilder
{
  class Parameters;
  class World;

  namespace Features
  {
    namespace FaultModels
    {
      namespace Composition
      {
        class Interface;
      }  // namespace Composition
      namespace Grains
      {
        class Interface;
      }  // namespace Grains
      namespace Temperature
      {
        class Interface;
      }  // namespace Temperature
      namespace Velocity
      {
        class Interface;
      }  // namespace Temperature
    }  // namespace FaultModels

    class Fault final: public Interface
    {
      public:
        Fault(WorldBuilder::World *world);

        ~Fault() override final;

        static
        void declare_entries(Parameters &prm,
                             const std::string &parent_name = "",
                             const std::vector<std::string> &required_entries = {});

        static
        void make_snippet(Parameters &prm);

        void parse_entries(Parameters &prm) override final;


        const BoundingBox<2>  &get_surface_bounding_box () const;

        void
        properties(const Point<3> &position_in_cartesian_coordinates,
                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
                   const double depth,
                   const std::vector<std::array<unsigned int,3>> &properties,
                   const double gravity,
                   const std::vector<size_t> &entry_in_output,
                   std::vector<double> &output) const override final;

        Objects::PlaneDistances
        distance_to_feature_plane(const Point<3> &position_in_cartesian_coordinates,
                                  const Objects::NaturalCoordinate &position_in_natural_coordinates,
                                  const double depth) const override;

      private:
        std::vector<std::shared_ptr<Features::FaultModels::Temperature::Interface> > default_temperature_models;
        std::vector<std::shared_ptr<Features::FaultModels::Composition::Interface>  > default_composition_models;
        std::vector<std::shared_ptr<Features::FaultModels::Grains::Interface>  > default_grains_models;
        std::vector<std::shared_ptr<Features::FaultModels::Velocity::Interface>  > default_velocity_models;

        std::vector<Objects::Segment<Features::FaultModels::Temperature::Interface,
            Features::FaultModels::Composition::Interface,
            Features::FaultModels::Grains::Interface,
            Features::FaultModels::Velocity::Interface> > default_segment_vector;

        std::vector< std::vector<Objects::Segment<Features::FaultModels::Temperature::Interface,
            Features::FaultModels::Composition::Interface,
            Features::FaultModels::Grains::Interface,
            Features::FaultModels::Velocity::Interface> > > sections_segment_vector;

        // This vector stores segments to this coordinate/section.
        //First used (raw) pointers to the segment relevant to this coordinate/section,
        // but I do not trust it won't fail when memory is moved. So storing the all the data now.
        std::vector<std::vector<Objects::Segment<Features::FaultModels::Temperature::Interface,
            Features::FaultModels::Composition::Interface,
            Features::FaultModels::Grains::Interface,
            Features::FaultModels::Velocity::Interface> > > segment_vector;

        // todo: the memory of this can be greatly improved by
        // or using a plugin system for the submodules, or
        // putting the variables in a union. Although the memory
        // used by this program is in real cases expected to be
        // insignificant compared to what a calling program may
        // use, a smaller amount of memory used in here, could
        // theoretically speed up the computation, because more
        // relevant data could be stored in the cache. But this
        // not a urgent problem, and would require testing.

        double starting_depth;

        double maximum_depth;

        BoundingBox<2> surface_bounding_box;

        WorldBuilder::Point<2> reference_point;

        std::vector<std::vector<double> > fault_segment_lengths;
        std::vector<std::vector<Point<2> > > fault_segment_thickness;
        std::vector<std::vector<Point<2> > > fault_segment_top_truncation;
        std::vector<std::vector<Point<2> > > fault_segment_angles;
        std::vector<double> total_fault_length;
        double maximum_total_fault_length;
        double maximum_fault_thickness;

        double min_along_x;
        double max_along_x;
        double min_along_y;
        double max_along_y;
        double min_lat_cos_inv;
        double max_lat_cos_inv;
        double buffer_around_fault_cartesian;

    };
  } // namespace Features
} // namespace WorldBuilder

#endif