05_abstract_parametrizations_2D.f90

Go to the documentation of this file.

!----------------------------------------------------------------------------------------
!
! This file is part of EFTCAMB.
!
! Copyright (C) 2013-2016 by the EFTCAMB authors
!
! The EFTCAMB code is free software;
! You can use it, redistribute it, and/or modify it under the terms
! of the GNU General Public License as published by the Free Software Foundation;
! either version 3 of the License, or (at your option) any later version.
! The full text of the license can be found in the file eftcamb/LICENSE at
! the top level of the EFTCAMB distribution.
!
!----------------------------------------------------------------------------------------



!----------------------------------------------------------------------------------------


module eftcamb_abstract_parametrizations_2d

    use precision
    use amlutils
    use inifile
    use eft_def
    use eftcamb_mixed_algorithms
    use eftcamb_cache

    implicit none

    private

    public parametrized_function_2d

    !----------------------------------------------------------------------------------------
    type, abstract :: parametrized_function_2d

        integer                                     :: parameter_number
        character(len=:), allocatable               :: name
        character(len=:), allocatable               :: name_latex
        type(string)    , allocatable, dimension(:) :: param_names
        type(string)    , allocatable, dimension(:) :: param_names_latex

    contains

        ! initialization procedures:
        procedure( parametrizedfunction2dsetparamnumber   ), deferred :: set_param_number
        procedure :: param_number          => parametrizedfunction2dparamnumber            
        procedure :: set_name              => parametrizedfunction2dsetname                
        procedure :: set_param_names       => parametrizedfunction2dsetparamnames          
        procedure :: init_from_file        => parametrizedfunction2dinitfromfile           
        procedure( parametrizedfunction2dinitparams       ), deferred :: init_parameters
        ! utility functions:
        procedure :: feedback              => parametrizedfunction2dfeedback               
        procedure :: parameter_names       => parametrizedfunction2dparameternames         
        procedure :: parameter_names_latex => parametrizedfunction2dparameternameslatex    
        procedure( parametrizedfunction2dparametervalues  ), deferred :: parameter_value
        ! evaluation procedures:
        procedure( parametrizedfunction2dvalue              ), deferred :: value
        procedure( parametrizedfunction2dfirstderivativex   ), deferred :: first_derivative_x
        procedure( parametrizedfunction2dfirstderivativey   ), deferred :: first_derivative_y
        procedure( parametrizedfunction2dsecondderivativex  ), deferred :: second_derivative_x
        procedure( parametrizedfunction2dsecondderivativey  ), deferred :: second_derivative_y
        procedure( parametrizedfunction2dsecondderivativexy ), deferred :: second_derivative_xy

    end type parametrized_function_2d

    ! ---------------------------------------------------------------------------------------------
    ! parametrized_function_2D abstract interfaces: these are all the function procedures
    ! that the user HAS to override when writing its own parametrized 2D function.
    ! ---------------------------------------------------------------------------------------------

    abstract interface

        ! ---------------------------------------------------------------------------------------------
        subroutine parametrizedfunction2dsetparamnumber( self )
            use precision
            import parametrized_function_2d
            implicit none
            class(parametrized_function_2d)  :: self
        end subroutine parametrizedfunction2dsetparamnumber

        ! ---------------------------------------------------------------------------------------------
        subroutine parametrizedfunction2dinitparams( self, array )
            use precision
            import parametrized_function_2d
            implicit none
            class(parametrized_function_2d)                        :: self
            real(dl), dimension(self%parameter_number), intent(in) :: array
        end subroutine parametrizedfunction2dinitparams

        ! ---------------------------------------------------------------------------------------------
        subroutine parametrizedfunction2dparametervalues( self, i, value )
            use precision
            import parametrized_function_2d
            implicit none
            class(parametrized_function_2d) :: self
            integer , intent(in)            :: i
            real(dl), intent(out)           :: value
        end subroutine parametrizedfunction2dparametervalues

        ! ---------------------------------------------------------------------------------------------
        function parametrizedfunction2dvalue( self, x, y, eft_cache )
            use precision
            use    eftcamb_cache
            import parametrized_function_2d
            implicit none
            class(parametrized_function_2d)                    :: self
            real(dl), intent(in)                               :: x
            real(dl), intent(in)                               :: y
            type(eftcamb_timestep_cache), intent(in), optional :: eft_cache
            real(dl) :: parametrizedfunction2dvalue
        end function parametrizedfunction2dvalue

        ! ---------------------------------------------------------------------------------------------
        function parametrizedfunction2dfirstderivativex( self, x, y, eft_cache  )
            use    precision
            use    eftcamb_cache
            import parametrized_function_2d
            implicit none
            class(parametrized_function_2d)                    :: self
            real(dl), intent(in)                               :: x
            real(dl), intent(in)                               :: y
            type(eftcamb_timestep_cache), intent(in), optional :: eft_cache
            real(dl) :: parametrizedfunction2dfirstderivativex
        end function parametrizedfunction2dfirstderivativex

        ! ---------------------------------------------------------------------------------------------
        function parametrizedfunction2dfirstderivativey( self, x, y, eft_cache )
            use    precision
            use    eftcamb_cache
            import parametrized_function_2d
            implicit none
            class(parametrized_function_2d)                    :: self
            real(dl), intent(in)                               :: x
            real(dl), intent(in)                               :: y
            type(eftcamb_timestep_cache), intent(in), optional :: eft_cache
            real(dl) :: parametrizedfunction2dfirstderivativey
        end function parametrizedfunction2dfirstderivativey

        ! ---------------------------------------------------------------------------------------------
        function parametrizedfunction2dsecondderivativex( self, x, y, eft_cache )
            use    precision
            use    eftcamb_cache
            import parametrized_function_2d
            implicit none
            class(parametrized_function_2d)                    :: self
            real(dl), intent(in)                               :: x
            real(dl), intent(in)                               :: y
            type(eftcamb_timestep_cache), intent(in), optional :: eft_cache
            real(dl) :: parametrizedfunction2dsecondderivativex
        end function parametrizedfunction2dsecondderivativex

        ! ---------------------------------------------------------------------------------------------
        function parametrizedfunction2dsecondderivativey( self, x, y, eft_cache )
            use    precision
            use    eftcamb_cache
            import parametrized_function_2d
            implicit none
            class(parametrized_function_2d)                    :: self
            real(dl), intent(in)                               :: x
            real(dl), intent(in)                               :: y
            type(eftcamb_timestep_cache), intent(in), optional :: eft_cache
            real(dl) :: parametrizedfunction2dsecondderivativey
        end function parametrizedfunction2dsecondderivativey

        ! ---------------------------------------------------------------------------------------------
        function parametrizedfunction2dsecondderivativexy( self, x, y, eft_cache )
            use    precision
            use    eftcamb_cache
            import parametrized_function_2d
            implicit none
            class(parametrized_function_2d)                    :: self
            real(dl), intent(in)                               :: x
            real(dl), intent(in)                               :: y
            type(eftcamb_timestep_cache), intent(in), optional :: eft_cache
            real(dl) :: parametrizedfunction2dsecondderivativexy
        end function parametrizedfunction2dsecondderivativexy

         ! ---------------------------------------------------------------------------------------------

    end interface

    ! ---------------------------------------------------------------------------------------------

contains

    ! ---------------------------------------------------------------------------------------------
    function parametrizedfunction2dparamnumber( self )

        implicit none

        class(parametrized_function_2d)    :: self
        integer  :: ParametrizedFunction2DParamNumber

        parametrizedfunction2dparamnumber = self%parameter_number

    end function parametrizedfunction2dparamnumber

    ! ---------------------------------------------------------------------------------------------
    subroutine parametrizedfunction2dsetname( self, name, latexname )

        implicit none

        class(parametrized_function_2d)    :: self
        character(*), intent(in)           :: name
        character(*), intent(in), optional :: latexname

        ! ensure that the number of parameters is properly associated:
        call self%set_param_number()

        ! store the name of the function:
        self%name             = trim( name      )
        ! store the latex name of the function:
        if ( present(latexname) ) then
            self%name_latex   = trim( latexname )
        else
            self%name_latex   = trim( name      )
        end if

    end subroutine parametrizedfunction2dsetname

    ! ---------------------------------------------------------------------------------------------
    subroutine parametrizedfunction2dsetparamnames( self, param_names, param_names_latex )

        implicit none

        class(parametrized_function_2d)                   :: self
        character(*), intent(in), dimension(:)            :: param_names
        character(*), intent(in), dimension(:), optional  :: param_names_latex

        integer  :: num_params, ind

        ! ensure that the number of parameters is properly associated:
        call self%set_param_number()

        ! check the number of parameters:
        num_params = self%param_number()
        if (  num_params /= size(param_names) ) then
            write(*,*) 'In parametrized_function_1D:', self%name
            write(*,*) 'Length of param_names and number of parameters do not coincide.'
            write(*,*) 'Parameter number:', num_params
            write(*,*) 'Size of the param_names array:', size(param_names)
            call mpistop('EFTCAMB error')
        end if
        if ( present(param_names_latex) ) then
            ! check length:
            if (  num_params /= size(param_names_latex) ) then
                write(*,*) 'In parametrized_function_1D:', self%name
                write(*,*) 'Length of param_names_latex and number of parameters do not coincide.'
                write(*,*) 'Parameter number:', self%parameter_number
                write(*,*) 'Size of the param_names array:', size(param_names_latex)
                call mpistop('EFTCAMB error')
            end if
        end if

        ! allocate self%param_names and self%param_names_latex:
        if ( allocated(self%param_names) ) deallocate(self%param_names)
        allocate( self%param_names(num_params) )
        if ( allocated(self%param_names_latex) ) deallocate(self%param_names_latex)
        allocate( self%param_names_latex(num_params) )

        ! store the parameter names and latex param names:
        do ind=1, num_params
            self%param_names(ind)%string  = param_names(ind)
            if ( present(param_names_latex) ) then
                self%param_names_latex(ind)%string = param_names_latex(ind)
            else
                self%param_names_latex(ind)%string = param_names(ind)
            end if
        end do

    end subroutine parametrizedfunction2dsetparamnames

    ! ---------------------------------------------------------------------------------------------
    subroutine parametrizedfunction2dinitfromfile( self, Ini )

        implicit none

        class(parametrized_function_2d)    :: self
        type(tinifile)                     :: Ini

        character(len=EFT_names_max_length)          :: param_name
        real(dl), dimension( self%parameter_number ) :: parameters

        integer  :: i

        ! ensure that the number of parameters is properly associated:
        call self%set_param_number()

        ! read the parameters and store them in a vector:
        do i=1, self%parameter_number
            call self%parameter_names( i, param_name )
            parameters(i) = ini_read_double_file( ini, trim(param_name), 0._dl )
        end do
        ! initialize the function parameters from the vector:
        call self%init_parameters( parameters )

    end subroutine parametrizedfunction2dinitfromfile

    ! ---------------------------------------------------------------------------------------------
    subroutine parametrizedfunction2dfeedback( self, print_params )

        implicit none

        class(parametrized_function_2d)  :: self
        logical, optional                :: print_params

        integer                             :: i
        real(dl)                            :: param_value
        character(len=EFT_names_max_length) :: param_name

        if ( .not. present(print_params) ) print_params = .true.

        if ( self%parameter_number>0 ) then
            write(*,*)     'Parametrized function 2D: ', self%name
            if ( print_params ) then
                do i=1, self%parameter_number
                    call self%parameter_names( i, param_name  )
                    call self%parameter_value( i, param_value )
                    write(*,'(a23,a,F12.6)') param_name, '=', param_value
                end do
            end if
        end if

    end subroutine parametrizedfunction2dfeedback

    ! ---------------------------------------------------------------------------------------------
    subroutine parametrizedfunction2dparameternames( self, i, name )

        implicit none

        class(parametrized_function_2d) :: self
        integer     , intent(in)        :: i
        character(*), intent(out)       :: name

        ! check the input index:
        if ( i>self%parameter_number ) then
            write(*,*) 'In parametrized_function_2D:', self%name
            write(*,*) 'Illegal index for parameter_names.'
            write(*,*) 'Maximum value is:', self%parameter_number
            call mpistop('EFTCAMB error')
        end if
        ! return the parameter name:
        if ( allocated(self%param_names) ) then
            name = self%param_names(i)%string
        else
            name = trim(self%name)//integer_to_string(i-1)
        end if

    end subroutine parametrizedfunction2dparameternames

    ! ---------------------------------------------------------------------------------------------
    subroutine parametrizedfunction2dparameternameslatex( self, i, latexname )

        implicit none

        class(parametrized_function_2d) :: self
        integer     , intent(in)        :: i
        character(*), intent(out)       :: latexname

        ! check the input index:
        if ( i>self%parameter_number ) then
            write(*,*) 'In parametrized_function_2D:', self%name
            write(*,*) 'Illegal index for parameter_names.'
            write(*,*) 'Maximum value is:', self%parameter_number
            call mpistop('EFTCAMB error')
        end if
        ! return the parameter name:
        if ( allocated(self%param_names_latex) ) then
            latexname = self%param_names_latex(i)%string
        else
            latexname = trim(self%name)//'_'//integer_to_string(i-1)
        end if

    end subroutine parametrizedfunction2dparameternameslatex

    !----------------------------------------------------------------------------------------
    
end module eftcamb_abstract_parametrizations_2d

!----------------------------------------------------------------------------------------