04_abstract_parametrizations_1D.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_1d

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

    implicit none

    private

    public parametrized_function_1d

    !----------------------------------------------------------------------------------------
    type, abstract :: parametrized_function_1d

        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( parametrizedfunction1dsetparamnumber   ), deferred :: set_param_number
        procedure :: param_number          => parametrizedfunction1dparamnumber            
        procedure :: set_name              => parametrizedfunction1dsetname                
        procedure :: set_param_names       => parametrizedfunction1dsetparamnames          
        procedure :: init_from_file        => parametrizedfunction1dinitfromfile           
        procedure( parametrizedfunction1dinitparams       ), deferred :: init_parameters
        ! utility functions:
        procedure :: feedback              => parametrizedfunction1dfeedback               
        procedure :: parameter_names       => parametrizedfunction1dparameternames         
        procedure :: parameter_names_latex => parametrizedfunction1dparameternameslatex    
        procedure( parametrizedfunction1dparametervalues  ), deferred :: parameter_value
        ! evaluation procedures:
        procedure( parametrizedfunction1dvalue            ), deferred :: value
        procedure( parametrizedfunction1dfirstderivative  ), deferred :: first_derivative
        procedure( parametrizedfunction1dsecondderivative ), deferred :: second_derivative
        procedure( parametrizedfunction1dthirdderivative  ), deferred :: third_derivative
        procedure( parametrizedfunction1dintegral         ), deferred :: integral

    end type parametrized_function_1d

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

    abstract interface

        ! ---------------------------------------------------------------------------------------------
        subroutine parametrizedfunction1dsetparamnumber( self )
            use precision
            import parametrized_function_1d
            implicit none
            class(parametrized_function_1d)  :: self
        end subroutine parametrizedfunction1dsetparamnumber

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

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

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

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

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

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

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

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

    end interface

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

contains

    ! ---------------------------------------------------------------------------------------------
    function parametrizedfunction1dparamnumber( self )

        implicit none

        class(parametrized_function_1d)    :: self
        integer  :: ParametrizedFunction1DParamNumber

        parametrizedfunction1dparamnumber = self%parameter_number

    end function parametrizedfunction1dparamnumber

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

        implicit none

        class(parametrized_function_1d)    :: 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 parametrizedfunction1dsetname

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

        implicit none

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

        character(len=:), allocatable :: string_array(:)

        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 parametrizedfunction1dsetparamnames

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

        implicit none

        class(parametrized_function_1d)    :: 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 parametrizedfunction1dinitfromfile

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

        implicit none

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

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

        if ( present(print_params) ) then
            print_params_temp = print_params
        else
            print_params_temp = .true.
        end if

        if ( self%parameter_number>0 ) then
            write(*,*)     'Parametrized function 1D: ', self%name
            if ( print_params_temp ) 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 parametrizedfunction1dfeedback

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

        implicit none

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

        ! check the input index:
        if ( i>self%parameter_number ) then
            write(*,*) 'In parametrized_function_1D:', 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 parametrizedfunction1dparameternames

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

        implicit none

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

        ! check the input index:
        if ( i>self%parameter_number ) then
            write(*,*) 'In parametrized_function_1D:', 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 parametrizedfunction1dparameternameslatex

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

end module eftcamb_abstract_parametrizations_1d

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