d2/d3e/force__torque_8f90_source.html

! Copyright (c) 2023, The Neko Authors

! All rights reserved.

!

! Redistribution and use in source and binary forms, with or without

! modification, are permitted provided that the following conditions

! are met:

!

!   * Redistributions of source code must retain the above copyright

!     notice, this list of conditions and the following disclaimer.

!

!   * Redistributions in binary form must reproduce the above

!     copyright notice, this list of conditions and the following

!     disclaimer in the documentation and/or other materials provided

!     with the distribution.

!

!   * Neither the name of the authors nor the names of its

!     contributors may be used to endorse or promote products derived

!     from this software without specific prior written permission.

!

! THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

! "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

! LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

! FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

! COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

! INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

! BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

! LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

! CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

! LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

! ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

! POSSIBILITY OF SUCH DAMAGE.

!

!


module force_torque

  use num_types, only : rp, dp, sp

  use json_module, only : json_file

  use simulation_component, only : simulation_component_t

  use field_registry, only : neko_field_registry

  use scratch_registry, only : neko_scratch_registry

  use field, only : field_t

  use operators, only : curl

  use case, only : case_t

  use fld_file_output, only : fld_file_output_t

  use json_utils, only : json_get, json_get_or_default

  use field_writer, only : field_writer_t

  use coefs, only : coef_t

  use operators, only : strain_rate

  use vector, only : vector_t

  use dirichlet, only : dirichlet_t

  use drag_torque

  use logger, only : log_size, neko_log

  use comm

  use math, only : masked_red_copy, cadd, glsum, vcross

  use device_math, only : device_masked_red_copy, device_cadd, &

                          device_glsum, device_vcross

  use device


  implicit none

  private


  type, public, extends(simulation_component_t) :: force_torque_t

     type(field_t), pointer :: u

     type(field_t), pointer :: v

     type(field_t), pointer :: w

     type(field_t), pointer :: p


     !Masked working arrays

     type(vector_t) :: n1, n2, n3

     type(vector_t) :: r1, r2, r3

     type(vector_t) :: force1, force2, force3

     type(vector_t) :: force4, force5, force6

     type(vector_t) :: pmsk

     type(vector_t) :: s11msk, s22msk, s33msk, s12msk, s13msk, s23msk

     real(kind=rp) :: center(3) = 0.0_rp

     real(kind=rp) :: scale

     integer :: zone_id

     character(len=20) :: zone_name

     type(coef_t), pointer :: coef

     type(dirichlet_t) :: bc

     character(len=80) :: print_format


   contains

     procedure, pass(this) :: init => force_torque_init_from_json

     procedure, pass(this) :: init_from_attributes => &

        force_torque_init_from_attributes

     procedure, pass(this) :: free => force_torque_free

     procedure, pass(this) :: compute_ => force_torque_compute

  end type force_torque_t


contains


  subroutine force_torque_init_from_json(this, json, case)

    class(force_torque_t), intent(inout) :: this

    type(json_file), intent(inout) :: json

    class(case_t), intent(inout), target :: case

    integer :: zone_id

    real(kind=rp), allocatable :: center(:)

    character(len=:), allocatable :: zone_name

    real(kind=rp) :: scale

    logical :: long_print


    ! Add fields keyword to the json so that the field_writer picks it up.

    ! Will also add fields to the registry.


    call this%init_base(json, case)


    call json_get(json, 'zone_id', zone_id)

    call json_get_or_default(json, 'zone_name', zone_name, ' ')

    call json_get_or_default(json, 'scale', scale, 1.0_rp)

    call json_get_or_default(json, 'long_print', long_print, .false.)

    call json_get(json, 'center', center)

    call force_torque_init_from_attributes(this, zone_id, zone_name, &

                                           center, scale, case%fluid%c_xh, &

                                           long_print)


  end subroutine force_torque_init_from_json


  subroutine force_torque_init_from_attributes(this, zone_id, zone_name, &

                                               center, scale, coef, long_print)

    class(force_torque_t), intent(inout) :: this

    real(kind=rp), intent(in) :: center(3)

    real(kind=rp), intent(in) :: scale

    character(len=*), intent(in) :: zone_name

    integer, intent(in) :: zone_id

    type(coef_t), target, intent(in) :: coef

    logical, intent(in) :: long_print

    integer :: n_pts, glb_n_pts, ierr

    character(len=1000) :: log_buf


    this%coef => coef

    this%zone_id = zone_id

    this%center = center

    this%scale = scale

    this%zone_name = zone_name

    if (long_print ) then

       this%print_format = '(I7,E20.10,E20.10,E20.10,E20.10,A)'

    else

       this%print_format = '(I7,E13.5,E13.5,E13.5,E13.5,A)'

    end if


    this%u => neko_field_registry%get_field_by_name("u")

    this%v => neko_field_registry%get_field_by_name("v")

    this%w => neko_field_registry%get_field_by_name("w")

    this%p => neko_field_registry%get_field_by_name("p")


    call this%bc%init_base(this%coef)

    call this%bc%mark_zone(this%case%msh%labeled_zones(this%zone_id))

    call this%bc%finalize()

    n_pts = this%bc%msk(0)

    call this%n1%init(n_pts)

    call this%n2%init(n_pts)

    call this%n3%init(n_pts)

    call this%r1%init(n_pts)

    call this%r2%init(n_pts)

    call this%r3%init(n_pts)

    call this%force1%init(n_pts)

    call this%force2%init(n_pts)

    call this%force3%init(n_pts)

    call this%force4%init(n_pts)

    call this%force5%init(n_pts)

    call this%force6%init(n_pts)

    call this%s11msk%init(n_pts)

    call this%s22msk%init(n_pts)

    call this%s33msk%init(n_pts)

    call this%s12msk%init(n_pts)

    call this%s13msk%init(n_pts)

    call this%s23msk%init(n_pts)

    call this%pmsk%init(n_pts)

    call setup_normals(this%coef, this%bc%msk, this%bc%facet, &

         this%n1%x, this%n2%x, this%n3%x, n_pts)

    call masked_red_copy(this%r1%x, this%coef%dof%x, this%bc%msk, &

         this%u%size(), n_pts)

    call masked_red_copy(this%r2%x, this%coef%dof%y, this%bc%msk, &

         this%u%size(), n_pts)

    call masked_red_copy(this%r3%x, this%coef%dof%z, this%bc%msk, &

         this%u%size(), n_pts)


    call mpi_allreduce(n_pts, glb_n_pts, 1, &

         mpi_integer, mpi_sum, neko_comm, ierr)

    ! Print some information

    call neko_log%section('Force/torque calculation')

    write(log_buf, '(A,I4,A,A)') 'Zone ', zone_id, '   ', trim(zone_name)

    call neko_log%message(log_buf)

    write(log_buf, '(A,I6, I6)') 'Global number of GLL points in zone: ', glb_n_pts

    call neko_log%message(log_buf)

    write(log_buf, '(A,E15.7,E15.7,E15.7)') 'Average of zone''s coordinates: ', &

                                            glsum(this%r1%x, n_pts)/glb_n_pts, &

                                            glsum(this%r2%x, n_pts)/glb_n_pts, &

                                            glsum(this%r3%x, n_pts)/glb_n_pts

    call neko_log%message(log_buf)

    write(log_buf, '(A,E15.7,E15.7,E15.7)') 'Center for torque calculation: ', center

    call neko_log%message(log_buf)

    write(log_buf, '(A,E15.7)') 'Scale: ', scale

    call neko_log%message(log_buf)

    call neko_log%end_section()


    call cadd(this%r1%x,-center(1), n_pts)

    call cadd(this%r2%x,-center(2), n_pts)

    call cadd(this%r3%x,-center(3), n_pts)

    if (neko_bcknd_device .eq. 1 .and. n_pts .gt. 0) then

       call device_memcpy(this%n1%x, this%n1%x_d, n_pts, host_to_device, &

            .false.)

       call device_memcpy(this%n2%x, this%n2%x_d, n_pts, host_to_device, &

            .false.)

       call device_memcpy(this%n3%x, this%n3%x_d, n_pts, host_to_device, &

            .true.)

       call device_memcpy(this%r1%x, this%r1%x_d, n_pts, host_to_device, &

            .false.)

       call device_memcpy(this%r2%x, this%r2%x_d, n_pts, host_to_device, &

            .false.)

       call device_memcpy(this%r3%x, this%r3%x_d, n_pts, host_to_device, &

            .true.)

    end if


  end subroutine force_torque_init_from_attributes


  subroutine force_torque_free(this)

    class(force_torque_t), intent(inout) :: this

    call this%free_base()


    nullify(this%u)

    nullify(this%v)

    nullify(this%w)

    nullify(this%p)

    nullify(this%coef)


  end subroutine force_torque_free


  subroutine force_torque_compute(this, t, tstep)

    class(force_torque_t), intent(inout) :: this

    real(kind=rp), intent(in) :: t

    integer, intent(in) :: tstep

    real(kind=rp) :: dgtq(12) = 0.0_rp

    integer :: n_pts, temp_indices(6)

    type(field_t), pointer :: s11, s22, s33, s12, s13, s23

    character(len=1000) :: log_buf


    n_pts = this%bc%msk(0)


    call neko_scratch_registry%request_field(s11, temp_indices(1))

    call neko_scratch_registry%request_field(s12, temp_indices(2))

    call neko_scratch_registry%request_field(s13, temp_indices(3))

    call neko_scratch_registry%request_field(s22, temp_indices(4))

    call neko_scratch_registry%request_field(s23, temp_indices(5))

    call neko_scratch_registry%request_field(s33, temp_indices(6))


    call strain_rate(s11%x, s22%x, s33%x, s12%x, &

         s13%x, s23%x, this%u, this%v, this%w, this%coef)


    ! On the CPU we can actually just use the original subroutines...

    if (neko_bcknd_device .eq. 0) then

       call masked_red_copy(this%s11msk%x, s11%x, this%bc%msk, &

            this%u%size(), n_pts)

       call masked_red_copy(this%s22msk%x, s22%x, this%bc%msk, &

            this%u%size(), n_pts)

       call masked_red_copy(this%s33msk%x, s33%x, this%bc%msk, &

            this%u%size(), n_pts)

       call masked_red_copy(this%s12msk%x, s12%x, this%bc%msk, &

            this%u%size(), n_pts)

       call masked_red_copy(this%s13msk%x, s13%x, this%bc%msk, &

            this%u%size(), n_pts)

       call masked_red_copy(this%s23msk%x, s23%x, this%bc%msk, &

            this%u%size(), n_pts)

       call masked_red_copy(this%pmsk%x, this%p%x, this%bc%msk, &

            this%u%size(), n_pts)

       call calc_force_array(this%force1%x, this%force2%x, this%force3%x, &

                             this%force4%x, this%force5%x, this%force6%x, &

                             this%s11msk%x, &

                             this%s22msk%x, &

                             this%s33msk%x, &

                             this%s12msk%x, &

                             this%s13msk%x, &

                             this%s23msk%x, &

                             this%pmsk%x, &

                             this%n1%x, &

                             this%n2%x, &

                             this%n3%x, &

                             this%case%fluid%mu, &

                             n_pts)

       dgtq(1) = glsum(this%force1%x, n_pts)

       dgtq(2) = glsum(this%force2%x, n_pts)

       dgtq(3) = glsum(this%force3%x, n_pts)

       dgtq(4) = glsum(this%force4%x, n_pts)

       dgtq(5) = glsum(this%force5%x, n_pts)

       dgtq(6) = glsum(this%force6%x, n_pts)

       !Overwriting masked s11, s22, s33 as they are no longer needed

       this%s11msk = 0.0_rp

       this%s22msk = 0.0_rp

       this%s33msk = 0.0_rp

       call vcross(this%s11msk%x, this%s22msk%x, this%s33msk%x, &

                   this%r1%x, this%r2%x, this%r3%x, &

                   this%force1%x, this%force2%x, this%force3%x, n_pts)


       dgtq(7) = glsum(this%s11msk%x, n_pts)

       dgtq(8) = glsum(this%s22msk%x, n_pts)

       dgtq(9) = glsum(this%s33msk%x, n_pts)

       this%s11msk = 0.0_rp

       this%s22msk = 0.0_rp

       this%s33msk = 0.0_rp

       call vcross(this%s11msk%x, this%s22msk%x, this%s33msk%x, &

                    this%r1%x, this%r2%x, this%r3%x, &

                    this%force4%x, this%force5%x, this%force6%x, n_pts)

       dgtq(10) = glsum(this%s11msk%x, n_pts)

       dgtq(11) = glsum(this%s22msk%x, n_pts)

       dgtq(12) = glsum(this%s33msk%x, n_pts)

    else

       if (n_pts .gt. 0) then

          call device_masked_red_copy(this%s11msk%x_d, s11%x_d, &

                                      this%bc%msk_d, this%u%size(), n_pts)

          call device_masked_red_copy(this%s22msk%x_d, s22%x_d, &

                                      this%bc%msk_d, this%u%size(), n_pts)

          call device_masked_red_copy(this%s33msk%x_d, s33%x_d, &

                                      this%bc%msk_d, this%u%size(), n_pts)

          call device_masked_red_copy(this%s12msk%x_d, s12%x_d, &

                                      this%bc%msk_d, this%u%size(), n_pts)

          call device_masked_red_copy(this%s13msk%x_d, s13%x_d, &

                                      this%bc%msk_d, this%u%size(), n_pts)

          call device_masked_red_copy(this%s23msk%x_d, s23%x_d, &

                                      this%bc%msk_d, this%u%size(), n_pts)

          call device_masked_red_copy(this%pmsk%x_d, this%p%x_d,  &

                                      this%bc%msk_d, this%u%size(), n_pts)


          call device_calc_force_array(this%force1%x_d, this%force2%x_d, &

                             this%force3%x_d, &

                             this%force4%x_d, &

                             this%force5%x_d, &

                             this%force6%x_d, &

                             this%s11msk%x_d, &

                             this%s22msk%x_d, &

                             this%s33msk%x_d, &

                             this%s12msk%x_d, &

                             this%s13msk%x_d, &

                             this%s23msk%x_d, &

                             this%pmsk%x_d, &

                             this%n1%x_d, &

                             this%n2%x_d, &

                             this%n3%x_d, &

                             this%case%fluid%mu, &

                             n_pts)

          !Overwriting masked s11, s22, s33 as they are no longer needed

          call device_vcross(this%s11msk%x_d, this%s22msk%x_d, &

                             this%s33msk%x_d, &

                             this%r1%x_d, this%r2%x_d, this%r3%x_d, &

                             this%force1%x_d, this%force2%x_d, &

                             this%force3%x_d, n_pts)

          call device_vcross(this%s12msk%x_d,this%s13msk%x_d,this%s23msk%x_d, &

                      this%r1%x_d, this%r2%x_d, this%r3%x_d, &

                      this%force4%x_d, this%force5%x_d, this%force6%x_d, n_pts)

       end if

       dgtq(1) = device_glsum(this%force1%x_d, n_pts)

       dgtq(2) = device_glsum(this%force2%x_d, n_pts)

       dgtq(3) = device_glsum(this%force3%x_d, n_pts)

       dgtq(4) = device_glsum(this%force4%x_d, n_pts)

       dgtq(5) = device_glsum(this%force5%x_d, n_pts)

       dgtq(6) = device_glsum(this%force6%x_d, n_pts)

       dgtq(7) = device_glsum(this%s11msk%x_d, n_pts)

       dgtq(8) = device_glsum(this%s22msk%x_d, n_pts)

       dgtq(9) = device_glsum(this%s33msk%x_d, n_pts)

       dgtq(10) = device_glsum(this%s12msk%x_d, n_pts)

       dgtq(11) = device_glsum(this%s13msk%x_d, n_pts)

       dgtq(12) = device_glsum(this%s23msk%x_d, n_pts)

    end if

    dgtq = this%scale*dgtq

    write(log_buf,'(A, I4, A, A)') 'Force and torque on zone ', &

          this%zone_id,'  ', this%zone_name

    call neko_log%message(log_buf)

    write(log_buf,'(A)') &

          'Time step, time, total force/torque, pressure, viscous, direction'

    call neko_log%message(log_buf)

    write(log_buf, this%print_format) &

          tstep,t,dgtq(1)+dgtq(4),dgtq(1),dgtq(4),', forcex'

    call neko_log%message(log_buf)

    write(log_buf, this%print_format) &

         tstep,t,dgtq(2)+dgtq(5),dgtq(2),dgtq(5),', forcey'

    call neko_log%message(log_buf)

    write(log_buf, this%print_format) &

         tstep,t,dgtq(3)+dgtq(6),dgtq(3),dgtq(6),', forcez'

    call neko_log%message(log_buf)

    write(log_buf, this%print_format) &

         tstep,t,dgtq(7)+dgtq(10),dgtq(7),dgtq(10),', torquex'

    call neko_log%message(log_buf)

    write(log_buf, this%print_format) &

         tstep,t,dgtq(8)+dgtq(11),dgtq(8),dgtq(11),', torquey'

    call neko_log%message(log_buf)

    write(log_buf, this%print_format) &

         tstep,t,dgtq(9)+dgtq(12),dgtq(9),dgtq(12),', torquez'

    call neko_log%message(log_buf)

    call neko_scratch_registry%relinquish_field(temp_indices)


  end subroutine force_torque_compute


end module force_torque

device::device_memcpy
Copy data between host and device (or device and device)
Definition device.F90:51

json_utils::json_get_or_default
Retrieves a parameter by name or assigns a provided default value. In the latter case also adds the m...
Definition json_utils.f90:54

json_utils::json_get
Retrieves a parameter by name or throws an error.
Definition json_utils.f90:45

bc
Defines a boundary condition.
Definition bc.f90:34

case
Defines a simulation case.
Definition case.f90:34

coefs
Coefficients.
Definition coef.f90:34

comm
Definition comm.F90:1

comm::neko_comm
type(mpi_comm) neko_comm
MPI communicator.
Definition comm.F90:16

device_math
Definition device_math.F90:33

device_math::device_cadd
subroutine, public device_cadd(a_d, c, n)
Add a scalar to vector .
Definition device_math.F90:198

device_math::device_masked_red_copy
subroutine, public device_masked_red_copy(a_d, b_d, mask_d, n, m)
Definition device_math.F90:105

device_math::device_vcross
subroutine, public device_vcross(u1_d, u2_d, u3_d, v1_d, v2_d, v3_d, w1_d, w2_d, w3_d, n)
Compute a cross product  (3-d version) assuming vector components  etc.
Definition device_math.F90:508

device_math::device_glsum
real(kind=rp) function, public device_glsum(a_d, n)
Sum a vector of length n.
Definition device_math.F90:629

device
Device abstraction, common interface for various accelerators.
Definition device.F90:34

device::host_to_device
integer, parameter, public host_to_device
Definition device.F90:47

dirichlet
Defines a dirichlet boundary condition.
Definition dirichlet.f90:34

drag_torque
Definition drag_torque.f90:61

drag_torque::setup_normals
subroutine, public setup_normals(coef, mask, facets, n1, n2, n3, n_pts)
Definition drag_torque.f90:448

drag_torque::device_calc_force_array
subroutine, public device_calc_force_array(force1, force2, force3, force4, force5, force6, s11, s22, s33, s12, s13, s23, p, n1, n2, n3, v, n_pts)
Calculate drag and torque from array of points.
Definition drag_torque.f90:418

drag_torque::calc_force_array
subroutine, public calc_force_array(force1, force2, force3, force4, force5, force6, s11, s22, s33, s12, s13, s23, p, n1, n2, n3, v, n_pts)
Calculate drag and torque from array of points.
Definition drag_torque.f90:381

field_registry
Defines a registry for storing solution fields.
Definition field_registry.f90:35

field_registry::neko_field_registry
type(field_registry_t), target, public neko_field_registry
Global field registry.
Definition field_registry.f90:75

field_writer
Implements the field_writer_t type.
Definition field_writer.f90:36

field
Defines a field.
Definition field.f90:34

fld_file_output
Implements fld_file_output_t.
Definition fld_file_output.f90:34

force_torque
Implements the force_torque_t type.
Definition force_torque.f90:36

force_torque::force_torque_init_from_attributes
subroutine force_torque_init_from_attributes(this, zone_id, zone_name, center, scale, coef, long_print)
Actual constructor.
Definition force_torque.f90:133

force_torque::force_torque_free
subroutine force_torque_free(this)
Destructor.
Definition force_torque.f90:233

force_torque::force_torque_compute
subroutine force_torque_compute(this, t, tstep)
Compute the force_torque field.
Definition force_torque.f90:247

force_torque::force_torque_init_from_json
subroutine force_torque_init_from_json(this, json, case)
Constructor from json.
Definition force_torque.f90:106

json_utils
Utilities for retrieving parameters from the case files.
Definition json_utils.f90:34

logger
Logging routines.
Definition log.f90:34

logger::neko_log
type(log_t), public neko_log
Global log stream.
Definition log.f90:65

logger::log_size
integer, parameter, public log_size
Definition log.f90:42

math
Definition math.f90:60

math::cadd
subroutine, public cadd(a, s, n)
Add a scalar to vector .
Definition math.f90:322

math::masked_red_copy
subroutine, public masked_red_copy(a, b, mask, n, m)
Copy a masked vector to reduced contigous vector .
Definition math.f90:279

math::glsum
real(kind=rp) function, public glsum(a, n)
Sum a vector of length n.
Definition math.f90:359

math::vcross
subroutine, public vcross(u1, u2, u3, v1, v2, v3, w1, w2, w3, n)
Compute a cross product  assuming vector components  etc.
Definition math.f90:513

num_types
Definition num_types.f90:1

num_types::dp
integer, parameter, public dp
Definition num_types.f90:9

num_types::sp
integer, parameter, public sp
Definition num_types.f90:8

num_types::rp
integer, parameter, public rp
Global precision used in computations.
Definition num_types.f90:12

operators
Operators.
Definition operators.f90:34

operators::curl
subroutine, public curl(w1, w2, w3, u1, u2, u3, work1, work2, coef)
Definition operators.f90:368

operators::strain_rate
subroutine, public strain_rate(s11, s22, s33, s12, s13, s23, u, v, w, coef)
Compute the strain rate tensor, i.e 0.5 * du_i/dx_j + du_j/dx_i.
Definition operators.f90:436

scratch_registry
Defines a registry for storing and requesting temporary fields This can be used when you have a funct...
Definition scratch_registry.f90:37

scratch_registry::init
type(scratch_registry_t) function init(dof, size, expansion_size)
Constructor, optionally taking initial registry and expansion size as argument.
Definition scratch_registry.f90:92

scratch_registry::neko_scratch_registry
type(scratch_registry_t), target, public neko_scratch_registry
Global scratch registry.
Definition scratch_registry.f90:85

simulation_component
Simulation components are objects that encapsulate functionality that can be fit to a particular comp...
Definition simulation_component.f90:38

simulation_component::compute_
subroutine compute_(this, t, tstep)
Dummy compute function.
Definition simulation_component.f90:255

vector
Defines a vector.
Definition vector.f90:34

case::case_t
Definition case.f90:62

coefs::coef_t
Coefficients defined on a given (mesh, ) tuple. Arrays use indices (i,j,k,e): element e,...
Definition coef.f90:55

dirichlet::dirichlet_t
Generic Dirichlet boundary condition  on .
Definition dirichlet.f90:44

field::field_t
Definition field.f90:46

field_writer::field_writer_t
A simulation component that writes a 3d field to a file.
Definition field_writer.f90:48

fld_file_output::fld_file_output_t
A simple output saving a list of fields to a .fld file.
Definition fld_file_output.f90:44

force_torque::force_torque_t
A simulation component that computes the force_torque field. Added to the field registry as omega_x,...
Definition force_torque.f90:65

simulation_component::simulation_component_t
Base abstract class for simulation components.
Definition simulation_component.f90:48

vector::vector_t
Definition vector.f90:46