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:449

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:419

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:382

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:323

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:280

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

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:514

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:362

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:430

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::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

vector
Defines a vector.
Definition: vector.f90:34

case::case_t
Definition: case.f90:63

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:50

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