penf_allocatable_memory Module

PENF allocatable memory facility. Wrap allocatable arrays routines providing extra information about memory handling.


Uses

  • module~~penf_allocatable_memory~~UsesGraph module~penf_allocatable_memory penf_allocatable_memory iso_fortran_env iso_fortran_env module~penf_allocatable_memory->iso_fortran_env module~penf_global_parameters_variables penf_global_parameters_variables module~penf_allocatable_memory->module~penf_global_parameters_variables module~penf_stringify penf_stringify module~penf_allocatable_memory->module~penf_stringify module~penf_stringify->iso_fortran_env module~penf_stringify->module~penf_global_parameters_variables module~penf_b_size penf_b_size module~penf_stringify->module~penf_b_size module~penf_b_size->module~penf_global_parameters_variables

Used by

  • module~~penf_allocatable_memory~~UsedByGraph module~penf_allocatable_memory penf_allocatable_memory module~penf penf module~penf->module~penf_allocatable_memory program~volatile_doctest~100 volatile_doctest program~volatile_doctest~100->module~penf_allocatable_memory program~volatile_doctest~100->module~penf program~volatile_doctest~101 volatile_doctest program~volatile_doctest~101->module~penf_allocatable_memory program~volatile_doctest~101->module~penf program~volatile_doctest~103 volatile_doctest program~volatile_doctest~103->module~penf_allocatable_memory program~volatile_doctest~103->module~penf program~volatile_doctest~104 volatile_doctest program~volatile_doctest~104->module~penf_allocatable_memory program~volatile_doctest~104->module~penf program~volatile_doctest~106 volatile_doctest program~volatile_doctest~106->module~penf_allocatable_memory program~volatile_doctest~106->module~penf program~volatile_doctest~109 volatile_doctest program~volatile_doctest~109->module~penf_allocatable_memory program~volatile_doctest~109->module~penf program~volatile_doctest~11 volatile_doctest program~volatile_doctest~11->module~penf_allocatable_memory program~volatile_doctest~11->module~penf program~volatile_doctest~111 volatile_doctest program~volatile_doctest~111->module~penf_allocatable_memory program~volatile_doctest~111->module~penf program~volatile_doctest~112 volatile_doctest program~volatile_doctest~112->module~penf_allocatable_memory program~volatile_doctest~112->module~penf program~volatile_doctest~114 volatile_doctest program~volatile_doctest~114->module~penf_allocatable_memory program~volatile_doctest~114->module~penf program~volatile_doctest~117 volatile_doctest program~volatile_doctest~117->module~penf_allocatable_memory program~volatile_doctest~117->module~penf program~volatile_doctest~124 volatile_doctest program~volatile_doctest~124->module~penf_allocatable_memory program~volatile_doctest~124->module~penf program~volatile_doctest~125 volatile_doctest program~volatile_doctest~125->module~penf_allocatable_memory program~volatile_doctest~125->module~penf program~volatile_doctest~126 volatile_doctest program~volatile_doctest~126->module~penf_allocatable_memory program~volatile_doctest~126->module~penf program~volatile_doctest~129 volatile_doctest program~volatile_doctest~129->module~penf_allocatable_memory program~volatile_doctest~129->module~penf program~volatile_doctest~131 volatile_doctest program~volatile_doctest~131->module~penf_allocatable_memory program~volatile_doctest~131->module~penf program~volatile_doctest~134 volatile_doctest program~volatile_doctest~134->module~penf_allocatable_memory program~volatile_doctest~134->module~penf program~volatile_doctest~138 volatile_doctest program~volatile_doctest~138->module~penf_allocatable_memory program~volatile_doctest~138->module~penf program~volatile_doctest~14 volatile_doctest program~volatile_doctest~14->module~penf_allocatable_memory program~volatile_doctest~14->module~penf program~volatile_doctest~140 volatile_doctest program~volatile_doctest~140->module~penf_allocatable_memory program~volatile_doctest~140->module~penf program~volatile_doctest~141 volatile_doctest program~volatile_doctest~141->module~penf_allocatable_memory program~volatile_doctest~141->module~penf program~volatile_doctest~142 volatile_doctest program~volatile_doctest~142->module~penf_allocatable_memory program~volatile_doctest~142->module~penf program~volatile_doctest~144 volatile_doctest program~volatile_doctest~144->module~penf_allocatable_memory program~volatile_doctest~144->module~penf program~volatile_doctest~147 volatile_doctest program~volatile_doctest~147->module~penf_allocatable_memory program~volatile_doctest~147->module~penf program~volatile_doctest~148 volatile_doctest program~volatile_doctest~148->module~penf_allocatable_memory program~volatile_doctest~148->module~penf program~volatile_doctest~153 volatile_doctest program~volatile_doctest~153->module~penf_allocatable_memory program~volatile_doctest~153->module~penf program~volatile_doctest~154 volatile_doctest program~volatile_doctest~154->module~penf_allocatable_memory program~volatile_doctest~154->module~penf program~volatile_doctest~155 volatile_doctest program~volatile_doctest~155->module~penf_allocatable_memory program~volatile_doctest~155->module~penf program~volatile_doctest~161 volatile_doctest program~volatile_doctest~161->module~penf_allocatable_memory program~volatile_doctest~161->module~penf program~volatile_doctest~163 volatile_doctest program~volatile_doctest~163->module~penf_allocatable_memory program~volatile_doctest~163->module~penf program~volatile_doctest~165 volatile_doctest program~volatile_doctest~165->module~penf_allocatable_memory program~volatile_doctest~165->module~penf program~volatile_doctest~166 volatile_doctest program~volatile_doctest~166->module~penf_allocatable_memory program~volatile_doctest~166->module~penf program~volatile_doctest~167 volatile_doctest program~volatile_doctest~167->module~penf_allocatable_memory program~volatile_doctest~167->module~penf program~volatile_doctest~174 volatile_doctest program~volatile_doctest~174->module~penf_allocatable_memory program~volatile_doctest~174->module~penf program~volatile_doctest~179 volatile_doctest program~volatile_doctest~179->module~penf_allocatable_memory program~volatile_doctest~179->module~penf program~volatile_doctest~180 volatile_doctest program~volatile_doctest~180->module~penf_allocatable_memory program~volatile_doctest~180->module~penf program~volatile_doctest~182 volatile_doctest program~volatile_doctest~182->module~penf_allocatable_memory program~volatile_doctest~182->module~penf program~volatile_doctest~183 volatile_doctest program~volatile_doctest~183->module~penf_allocatable_memory program~volatile_doctest~183->module~penf program~volatile_doctest~186 volatile_doctest program~volatile_doctest~186->module~penf_allocatable_memory program~volatile_doctest~186->module~penf program~volatile_doctest~19 volatile_doctest program~volatile_doctest~19->module~penf_allocatable_memory program~volatile_doctest~19->module~penf program~volatile_doctest~190 volatile_doctest program~volatile_doctest~190->module~penf_allocatable_memory program~volatile_doctest~190->module~penf program~volatile_doctest~191 volatile_doctest program~volatile_doctest~191->module~penf_allocatable_memory program~volatile_doctest~191->module~penf program~volatile_doctest~192 volatile_doctest program~volatile_doctest~192->module~penf_allocatable_memory program~volatile_doctest~192->module~penf program~volatile_doctest~193 volatile_doctest program~volatile_doctest~193->module~penf_allocatable_memory program~volatile_doctest~193->module~penf program~volatile_doctest~194 volatile_doctest program~volatile_doctest~194->module~penf_allocatable_memory program~volatile_doctest~194->module~penf program~volatile_doctest~196 volatile_doctest program~volatile_doctest~196->module~penf_allocatable_memory program~volatile_doctest~196->module~penf program~volatile_doctest~197 volatile_doctest program~volatile_doctest~197->module~penf_allocatable_memory program~volatile_doctest~197->module~penf program~volatile_doctest~199 volatile_doctest program~volatile_doctest~199->module~penf_allocatable_memory program~volatile_doctest~199->module~penf program~volatile_doctest~2 volatile_doctest program~volatile_doctest~2->module~penf_allocatable_memory program~volatile_doctest~2->module~penf program~volatile_doctest~20 volatile_doctest program~volatile_doctest~20->module~penf_allocatable_memory program~volatile_doctest~20->module~penf program~volatile_doctest~200 volatile_doctest program~volatile_doctest~200->module~penf_allocatable_memory program~volatile_doctest~200->module~penf program~volatile_doctest~205 volatile_doctest program~volatile_doctest~205->module~penf_allocatable_memory program~volatile_doctest~205->module~penf program~volatile_doctest~206 volatile_doctest program~volatile_doctest~206->module~penf_allocatable_memory program~volatile_doctest~206->module~penf program~volatile_doctest~208 volatile_doctest program~volatile_doctest~208->module~penf_allocatable_memory program~volatile_doctest~208->module~penf program~volatile_doctest~21 volatile_doctest program~volatile_doctest~21->module~penf_allocatable_memory program~volatile_doctest~21->module~penf program~volatile_doctest~27 volatile_doctest program~volatile_doctest~27->module~penf_allocatable_memory program~volatile_doctest~27->module~penf program~volatile_doctest~28 volatile_doctest program~volatile_doctest~28->module~penf_allocatable_memory program~volatile_doctest~28->module~penf program~volatile_doctest~3 volatile_doctest program~volatile_doctest~3->module~penf_allocatable_memory program~volatile_doctest~3->module~penf program~volatile_doctest~30 volatile_doctest program~volatile_doctest~30->module~penf_allocatable_memory program~volatile_doctest~30->module~penf program~volatile_doctest~32 volatile_doctest program~volatile_doctest~32->module~penf_allocatable_memory program~volatile_doctest~32->module~penf program~volatile_doctest~34 volatile_doctest program~volatile_doctest~34->module~penf_allocatable_memory program~volatile_doctest~34->module~penf program~volatile_doctest~37 volatile_doctest program~volatile_doctest~37->module~penf_allocatable_memory program~volatile_doctest~37->module~penf program~volatile_doctest~4 volatile_doctest program~volatile_doctest~4->module~penf_allocatable_memory program~volatile_doctest~4->module~penf program~volatile_doctest~40 volatile_doctest program~volatile_doctest~40->module~penf_allocatable_memory program~volatile_doctest~40->module~penf program~volatile_doctest~43 volatile_doctest program~volatile_doctest~43->module~penf_allocatable_memory program~volatile_doctest~43->module~penf program~volatile_doctest~45 volatile_doctest program~volatile_doctest~45->module~penf_allocatable_memory program~volatile_doctest~45->module~penf program~volatile_doctest~47 volatile_doctest program~volatile_doctest~47->module~penf_allocatable_memory program~volatile_doctest~47->module~penf program~volatile_doctest~49 volatile_doctest program~volatile_doctest~49->module~penf_allocatable_memory program~volatile_doctest~49->module~penf program~volatile_doctest~50 volatile_doctest program~volatile_doctest~50->module~penf_allocatable_memory program~volatile_doctest~50->module~penf program~volatile_doctest~54 volatile_doctest program~volatile_doctest~54->module~penf_allocatable_memory program~volatile_doctest~54->module~penf program~volatile_doctest~56 volatile_doctest program~volatile_doctest~56->module~penf_allocatable_memory program~volatile_doctest~56->module~penf program~volatile_doctest~57 volatile_doctest program~volatile_doctest~57->module~penf_allocatable_memory program~volatile_doctest~57->module~penf program~volatile_doctest~59 volatile_doctest program~volatile_doctest~59->module~penf_allocatable_memory program~volatile_doctest~59->module~penf program~volatile_doctest~6 volatile_doctest program~volatile_doctest~6->module~penf_allocatable_memory program~volatile_doctest~6->module~penf program~volatile_doctest~60 volatile_doctest program~volatile_doctest~60->module~penf_allocatable_memory program~volatile_doctest~60->module~penf program~volatile_doctest~62 volatile_doctest program~volatile_doctest~62->module~penf_allocatable_memory program~volatile_doctest~62->module~penf program~volatile_doctest~63 volatile_doctest program~volatile_doctest~63->module~penf_allocatable_memory program~volatile_doctest~63->module~penf program~volatile_doctest~64 volatile_doctest program~volatile_doctest~64->module~penf_allocatable_memory program~volatile_doctest~64->module~penf program~volatile_doctest~69 volatile_doctest program~volatile_doctest~69->module~penf_allocatable_memory program~volatile_doctest~69->module~penf program~volatile_doctest~7 volatile_doctest program~volatile_doctest~7->module~penf_allocatable_memory program~volatile_doctest~7->module~penf program~volatile_doctest~70 volatile_doctest program~volatile_doctest~70->module~penf_allocatable_memory program~volatile_doctest~70->module~penf program~volatile_doctest~71 volatile_doctest program~volatile_doctest~71->module~penf_allocatable_memory program~volatile_doctest~71->module~penf program~volatile_doctest~72 volatile_doctest program~volatile_doctest~72->module~penf_allocatable_memory program~volatile_doctest~72->module~penf program~volatile_doctest~73 volatile_doctest program~volatile_doctest~73->module~penf_allocatable_memory program~volatile_doctest~73->module~penf program~volatile_doctest~74 volatile_doctest program~volatile_doctest~74->module~penf_allocatable_memory program~volatile_doctest~74->module~penf program~volatile_doctest~77 volatile_doctest program~volatile_doctest~77->module~penf_allocatable_memory program~volatile_doctest~77->module~penf program~volatile_doctest~8 volatile_doctest program~volatile_doctest~8->module~penf_allocatable_memory program~volatile_doctest~8->module~penf program~volatile_doctest~80 volatile_doctest program~volatile_doctest~80->module~penf_allocatable_memory program~volatile_doctest~80->module~penf program~volatile_doctest~81 volatile_doctest program~volatile_doctest~81->module~penf_allocatable_memory program~volatile_doctest~81->module~penf program~volatile_doctest~83 volatile_doctest program~volatile_doctest~83->module~penf_allocatable_memory program~volatile_doctest~83->module~penf program~volatile_doctest~85 volatile_doctest program~volatile_doctest~85->module~penf_allocatable_memory program~volatile_doctest~85->module~penf program~volatile_doctest~88 volatile_doctest program~volatile_doctest~88->module~penf_allocatable_memory program~volatile_doctest~88->module~penf program~volatile_doctest~90 volatile_doctest program~volatile_doctest~90->module~penf_allocatable_memory program~volatile_doctest~90->module~penf program~volatile_doctest~91 volatile_doctest program~volatile_doctest~91->module~penf_allocatable_memory program~volatile_doctest~91->module~penf program~volatile_doctest~93 volatile_doctest program~volatile_doctest~93->module~penf_allocatable_memory program~volatile_doctest~93->module~penf program~volatile_doctest~95 volatile_doctest program~volatile_doctest~95->module~penf_allocatable_memory program~volatile_doctest~95->module~penf program~volatile_doctest~97 volatile_doctest program~volatile_doctest~97->module~penf_allocatable_memory program~volatile_doctest~97->module~penf program~volatile_doctest~98 volatile_doctest program~volatile_doctest~98->module~penf_allocatable_memory program~volatile_doctest~98->module~penf program~volatile_doctest volatile_doctest program~volatile_doctest->module~penf program~volatile_doctest~10 volatile_doctest program~volatile_doctest~10->module~penf program~volatile_doctest~102 volatile_doctest program~volatile_doctest~102->module~penf program~volatile_doctest~105 volatile_doctest program~volatile_doctest~105->module~penf program~volatile_doctest~107 volatile_doctest program~volatile_doctest~107->module~penf program~volatile_doctest~108 volatile_doctest program~volatile_doctest~108->module~penf program~volatile_doctest~110 volatile_doctest program~volatile_doctest~110->module~penf program~volatile_doctest~113 volatile_doctest program~volatile_doctest~113->module~penf program~volatile_doctest~115 volatile_doctest program~volatile_doctest~115->module~penf program~volatile_doctest~116 volatile_doctest program~volatile_doctest~116->module~penf program~volatile_doctest~118 volatile_doctest program~volatile_doctest~118->module~penf program~volatile_doctest~119 volatile_doctest program~volatile_doctest~119->module~penf program~volatile_doctest~12 volatile_doctest program~volatile_doctest~12->module~penf program~volatile_doctest~120 volatile_doctest program~volatile_doctest~120->module~penf program~volatile_doctest~121 volatile_doctest program~volatile_doctest~121->module~penf program~volatile_doctest~122 volatile_doctest program~volatile_doctest~122->module~penf program~volatile_doctest~123 volatile_doctest program~volatile_doctest~123->module~penf program~volatile_doctest~127 volatile_doctest program~volatile_doctest~127->module~penf program~volatile_doctest~128 volatile_doctest program~volatile_doctest~128->module~penf program~volatile_doctest~13 volatile_doctest program~volatile_doctest~13->module~penf program~volatile_doctest~130 volatile_doctest program~volatile_doctest~130->module~penf program~volatile_doctest~132 volatile_doctest program~volatile_doctest~132->module~penf program~volatile_doctest~133 volatile_doctest program~volatile_doctest~133->module~penf program~volatile_doctest~135 volatile_doctest program~volatile_doctest~135->module~penf program~volatile_doctest~136 volatile_doctest program~volatile_doctest~136->module~penf program~volatile_doctest~137 volatile_doctest program~volatile_doctest~137->module~penf program~volatile_doctest~139 volatile_doctest program~volatile_doctest~139->module~penf program~volatile_doctest~143 volatile_doctest program~volatile_doctest~143->module~penf program~volatile_doctest~145 volatile_doctest program~volatile_doctest~145->module~penf program~volatile_doctest~146 volatile_doctest program~volatile_doctest~146->module~penf program~volatile_doctest~149 volatile_doctest program~volatile_doctest~149->module~penf program~volatile_doctest~15 volatile_doctest program~volatile_doctest~15->module~penf program~volatile_doctest~150 volatile_doctest program~volatile_doctest~150->module~penf program~volatile_doctest~151 volatile_doctest program~volatile_doctest~151->module~penf program~volatile_doctest~152 volatile_doctest program~volatile_doctest~152->module~penf program~volatile_doctest~156 volatile_doctest program~volatile_doctest~156->module~penf program~volatile_doctest~157 volatile_doctest program~volatile_doctest~157->module~penf program~volatile_doctest~158 volatile_doctest program~volatile_doctest~158->module~penf program~volatile_doctest~159 volatile_doctest program~volatile_doctest~159->module~penf program~volatile_doctest~16 volatile_doctest program~volatile_doctest~16->module~penf program~volatile_doctest~160 volatile_doctest program~volatile_doctest~160->module~penf program~volatile_doctest~162 volatile_doctest program~volatile_doctest~162->module~penf program~volatile_doctest~164 volatile_doctest program~volatile_doctest~164->module~penf program~volatile_doctest~168 volatile_doctest program~volatile_doctest~168->module~penf program~volatile_doctest~169 volatile_doctest program~volatile_doctest~169->module~penf program~volatile_doctest~17 volatile_doctest program~volatile_doctest~17->module~penf program~volatile_doctest~170 volatile_doctest program~volatile_doctest~170->module~penf program~volatile_doctest~171 volatile_doctest program~volatile_doctest~171->module~penf program~volatile_doctest~172 volatile_doctest program~volatile_doctest~172->module~penf program~volatile_doctest~173 volatile_doctest program~volatile_doctest~173->module~penf program~volatile_doctest~175 volatile_doctest program~volatile_doctest~175->module~penf program~volatile_doctest~176 volatile_doctest program~volatile_doctest~176->module~penf program~volatile_doctest~177 volatile_doctest program~volatile_doctest~177->module~penf program~volatile_doctest~178 volatile_doctest program~volatile_doctest~178->module~penf program~volatile_doctest~18 volatile_doctest program~volatile_doctest~18->module~penf program~volatile_doctest~181 volatile_doctest program~volatile_doctest~181->module~penf program~volatile_doctest~184 volatile_doctest program~volatile_doctest~184->module~penf program~volatile_doctest~185 volatile_doctest program~volatile_doctest~185->module~penf program~volatile_doctest~187 volatile_doctest program~volatile_doctest~187->module~penf program~volatile_doctest~188 volatile_doctest program~volatile_doctest~188->module~penf program~volatile_doctest~189 volatile_doctest program~volatile_doctest~189->module~penf program~volatile_doctest~195 volatile_doctest program~volatile_doctest~195->module~penf program~volatile_doctest~198 volatile_doctest program~volatile_doctest~198->module~penf program~volatile_doctest~201 volatile_doctest program~volatile_doctest~201->module~penf program~volatile_doctest~202 volatile_doctest program~volatile_doctest~202->module~penf program~volatile_doctest~203 volatile_doctest program~volatile_doctest~203->module~penf program~volatile_doctest~204 volatile_doctest program~volatile_doctest~204->module~penf program~volatile_doctest~207 volatile_doctest program~volatile_doctest~207->module~penf program~volatile_doctest~22 volatile_doctest program~volatile_doctest~22->module~penf program~volatile_doctest~23 volatile_doctest program~volatile_doctest~23->module~penf program~volatile_doctest~24 volatile_doctest program~volatile_doctest~24->module~penf program~volatile_doctest~25 volatile_doctest program~volatile_doctest~25->module~penf program~volatile_doctest~26 volatile_doctest program~volatile_doctest~26->module~penf program~volatile_doctest~29 volatile_doctest program~volatile_doctest~29->module~penf program~volatile_doctest~31 volatile_doctest program~volatile_doctest~31->module~penf program~volatile_doctest~33 volatile_doctest program~volatile_doctest~33->module~penf program~volatile_doctest~35 volatile_doctest program~volatile_doctest~35->module~penf program~volatile_doctest~36 volatile_doctest program~volatile_doctest~36->module~penf program~volatile_doctest~38 volatile_doctest program~volatile_doctest~38->module~penf program~volatile_doctest~39 volatile_doctest program~volatile_doctest~39->module~penf program~volatile_doctest~41 volatile_doctest program~volatile_doctest~41->module~penf program~volatile_doctest~42 volatile_doctest program~volatile_doctest~42->module~penf program~volatile_doctest~44 volatile_doctest program~volatile_doctest~44->module~penf program~volatile_doctest~46 volatile_doctest program~volatile_doctest~46->module~penf program~volatile_doctest~48 volatile_doctest program~volatile_doctest~48->module~penf program~volatile_doctest~5 volatile_doctest program~volatile_doctest~5->module~penf program~volatile_doctest~51 volatile_doctest program~volatile_doctest~51->module~penf program~volatile_doctest~52 volatile_doctest program~volatile_doctest~52->module~penf program~volatile_doctest~53 volatile_doctest program~volatile_doctest~53->module~penf program~volatile_doctest~55 volatile_doctest program~volatile_doctest~55->module~penf program~volatile_doctest~58 volatile_doctest program~volatile_doctest~58->module~penf program~volatile_doctest~61 volatile_doctest program~volatile_doctest~61->module~penf program~volatile_doctest~65 volatile_doctest program~volatile_doctest~65->module~penf program~volatile_doctest~66 volatile_doctest program~volatile_doctest~66->module~penf program~volatile_doctest~67 volatile_doctest program~volatile_doctest~67->module~penf program~volatile_doctest~68 volatile_doctest program~volatile_doctest~68->module~penf program~volatile_doctest~75 volatile_doctest program~volatile_doctest~75->module~penf program~volatile_doctest~76 volatile_doctest program~volatile_doctest~76->module~penf program~volatile_doctest~78 volatile_doctest program~volatile_doctest~78->module~penf program~volatile_doctest~79 volatile_doctest program~volatile_doctest~79->module~penf program~volatile_doctest~82 volatile_doctest program~volatile_doctest~82->module~penf program~volatile_doctest~84 volatile_doctest program~volatile_doctest~84->module~penf program~volatile_doctest~86 volatile_doctest program~volatile_doctest~86->module~penf program~volatile_doctest~87 volatile_doctest program~volatile_doctest~87->module~penf program~volatile_doctest~89 volatile_doctest program~volatile_doctest~89->module~penf program~volatile_doctest~9 volatile_doctest program~volatile_doctest~9->module~penf program~volatile_doctest~92 volatile_doctest program~volatile_doctest~92->module~penf program~volatile_doctest~94 volatile_doctest program~volatile_doctest~94->module~penf program~volatile_doctest~96 volatile_doctest program~volatile_doctest~96->module~penf program~volatile_doctest~99 volatile_doctest program~volatile_doctest~99->module~penf

Interfaces

public interface allocate_variable

Allocate CPU variable with memory checking.

  • private subroutine alloc_var_R8P_1D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind R8P, rank 1).

     use penf
 real(R8P), allocatable :: a(:)
 integer(I4P)           :: ulb(2)=[1,1]
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R8P), intent(inout), allocatable :: var(:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_R8P_2D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind R8P, rank 2).

     use penf
 real(R8P), allocatable :: a(:,:)
 integer(I4P)           :: ulb(2,2)=reshape([1,1, &
                                             1,2],&
                                            [2,2])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R8P), intent(inout), allocatable :: var(:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,2)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_R8P_3D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind R8P, rank 3).

     use penf
 real(R8P), allocatable :: a(:,:,:)
 integer(I4P)           :: ulb(2,3)=reshape([1,1, &
                                             1,2, &
                                             1,3],&
                                            [2,3])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R8P), intent(inout), allocatable :: var(:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,3)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_R8P_4D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind R8P, rank 4).

     use penf
 real(R8P), allocatable :: a(:,:,:,:)
 integer(I4P)           :: ulb(2,4)=reshape([1,1, &
                                             1,2, &
                                             1,3, &
                                             1,4],&
                                            [2,4])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R8P), intent(inout), allocatable :: var(:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,4)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_R8P_5D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind R8P, rank 5).

     use penf
 real(R8P), allocatable :: a(:,:,:,:,:)
 integer(I4P)           :: ulb(2,5)=reshape([1,1, &
                                             1,2, &
                                             1,3, &
                                             1,4, &
                                             1,5],&
                                            [2,5])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R8P), intent(inout), allocatable :: var(:,:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,5)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_R8P_6D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind R8P, rank 6).

     use penf
 real(R8P), allocatable :: a(:,:,:,:,:,:)
 integer(I4P)           :: ulb(2,6)=reshape([1,1, &
                                             1,2, &
                                             1,3, &
                                             1,4, &
                                             1,5, &
                                             1,6],&
                                            [2,6])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R8P), intent(inout), allocatable :: var(:,:,:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,6)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_R8P_7D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind R8P, rank 6).

     use penf
 real(R8P), allocatable :: a(:,:,:,:,:,:,:)
 integer(I4P)           :: ulb(2,7)=reshape([1,1, &
                                             1,2, &
                                             1,3, &
                                             1,4, &
                                             1,5, &
                                             1,6, &
                                             1,7],&
                                            [2,7])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R8P), intent(inout), allocatable :: var(:,:,:,:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,7)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_R4P_1D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind R4P, rank 1).

     use penf
 real(R4P), allocatable :: a(:)
 integer(I4P)           :: ulb(2)=[1,1]
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R4P), intent(inout), allocatable :: var(:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_R4P_2D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind R4P, rank 2).

     use penf
 real(R4P), allocatable :: a(:,:)
 integer(I4P)           :: ulb(2,2)=reshape([1,1, &
                                             1,2],&
                                            [2,2])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R4P), intent(inout), allocatable :: var(:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,2)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_R4P_3D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind R4P, rank 3).

     use penf
 real(R4P), allocatable :: a(:,:,:)
 integer(I4P)           :: ulb(2,3)=reshape([1,1, &
                                             1,2, &
                                             1,3],&
                                            [2,3])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R4P), intent(inout), allocatable :: var(:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,3)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_R4P_4D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind R4P, rank 4).

     use penf
 real(R4P), allocatable :: a(:,:,:,:)
 integer(I4P)           :: ulb(2,4)=reshape([1,1, &
                                             1,2, &
                                             1,3, &
                                             1,4],&
                                            [2,4])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R4P), intent(inout), allocatable :: var(:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,4)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_R4P_5D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind R4P, rank 5).

     use penf
 real(R4P), allocatable :: a(:,:,:,:,:)
 integer(I4P)           :: ulb(2,5)=reshape([1,1, &
                                             1,2, &
                                             1,3, &
                                             1,4, &
                                             1,5],&
                                            [2,5])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R4P), intent(inout), allocatable :: var(:,:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,5)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_R4P_6D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind R4P, rank 6).

     use penf
 real(R4P), allocatable :: a(:,:,:,:,:,:)
 integer(I4P)           :: ulb(2,6)=reshape([1,1, &
                                             1,2, &
                                             1,3, &
                                             1,4, &
                                             1,5, &
                                             1,6],&
                                            [2,6])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R4P), intent(inout), allocatable :: var(:,:,:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,6)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_R4P_7D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind R4P, rank 6).

     use penf
 real(R4P), allocatable :: a(:,:,:,:,:,:,:)
 integer(I4P)           :: ulb(2,7)=reshape([1,1, &
                                             1,2, &
                                             1,3, &
                                             1,4, &
                                             1,5, &
                                             1,6, &
                                             1,7],&
                                            [2,7])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R4P), intent(inout), allocatable :: var(:,:,:,:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,7)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I8P_1D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I8P, rank 1).

     use penf
 integer(I8P), allocatable :: a(:)
 integer(I4P)              :: ulb(2)=[1,1]
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I8P), intent(inout), allocatable :: var(:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I8P_2D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I8P, rank 2).

     use penf
 integer(I8P), allocatable :: a(:,:)
 integer(I4P)              :: ulb(2,2)=reshape([1,1, &
                                                1,2],&
                                               [2,2])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I8P), intent(inout), allocatable :: var(:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,2)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I8P_3D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I8P, rank 3).

     use penf
 integer(I8P), allocatable :: a(:,:,:)
 integer(I4P)              :: ulb(2,3)=reshape([1,1, &
                                                1,2, &
                                                1,3],&
                                               [2,3])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I8P), intent(inout), allocatable :: var(:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,3)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I8P_4D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I8P, rank 4).

     use penf
 integer(I8P), allocatable :: a(:,:,:,:)
 integer(I4P)              :: ulb(2,4)=reshape([1,1, &
                                                1,2, &
                                                1,3, &
                                                1,4],&
                                               [2,4])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I8P), intent(inout), allocatable :: var(:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,4)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I8P_5D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I8P, rank 5).

     use penf
 integer(I8P), allocatable :: a(:,:,:,:,:)
 integer(I4P)              :: ulb(2,5)=reshape([1,1, &
                                                1,2, &
                                                1,3, &
                                                1,4, &
                                                1,5],&
                                               [2,5])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I8P), intent(inout), allocatable :: var(:,:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,5)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I8P_6D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I8P, rank 6).

     use penf
 integer(I8P), allocatable :: a(:,:,:,:,:,:)
 integer(I4P)              :: ulb(2,6)=reshape([1,1, &
                                                1,2, &
                                                1,3, &
                                                1,4, &
                                                1,5, &
                                                1,6],&
                                               [2,6])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I8P), intent(inout), allocatable :: var(:,:,:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,6)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I8P_7D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I8P, rank 7).

     use penf
 integer(I8P), allocatable :: a(:,:,:,:,:,:,:)
 integer(I4P)              :: ulb(2,7)=reshape([1,1, &
                                                1,2, &
                                                1,3, &
                                                1,4, &
                                                1,5, &
                                                1,6, &
                                                1,7],&
                                               [2,7])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I8P), intent(inout), allocatable :: var(:,:,:,:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,7)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I4P_1D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I4P, rank 1).

     use penf
 integer(I4P), allocatable :: a(:)
 integer(I4P)              :: ulb(2)=[1,1]
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I4P), intent(inout), allocatable :: var(:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I4P_2D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I4P, rank 2).

     use penf
 integer(I4P), allocatable :: a(:,:)
 integer(I4P)              :: ulb(2,2)=reshape([1,1, &
                                                1,2],&
                                               [2,2])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I4P), intent(inout), allocatable :: var(:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,2)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I4P_3D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I4P, rank 3).

     use penf
 integer(I4P), allocatable :: a(:,:,:)
 integer(I4P)              :: ulb(2,3)=reshape([1,1, &
                                                1,2, &
                                                1,3],&
                                               [2,3])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I4P), intent(inout), allocatable :: var(:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,3)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I4P_4D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I4P, rank 4).

     use penf
 integer(I4P), allocatable :: a(:,:,:,:)
 integer(I4P)              :: ulb(2,4)=reshape([1,1, &
                                                1,2, &
                                                1,3, &
                                                1,4],&
                                               [2,4])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I4P), intent(inout), allocatable :: var(:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,4)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I4P_5D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I4P, rank 5).

     use penf
 integer(I4P), allocatable :: a(:,:,:,:,:)
 integer(I4P)              :: ulb(2,5)=reshape([1,1, &
                                                1,2, &
                                                1,3, &
                                                1,4, &
                                                1,5],&
                                               [2,5])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I4P), intent(inout), allocatable :: var(:,:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,5)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I4P_6D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I4P, rank 6).

     use penf
 integer(I4P), allocatable :: a(:,:,:,:,:,:)
 integer(I4P)              :: ulb(2,6)=reshape([1,1, &
                                                1,2, &
                                                1,3, &
                                                1,4, &
                                                1,5, &
                                                1,6],&
                                               [2,6])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I4P), intent(inout), allocatable :: var(:,:,:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,6)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I4P_7D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I4P, rank 7).

     use penf
 integer(I4P), allocatable :: a(:,:,:,:,:,:,:)
 integer(I4P)              :: ulb(2,7)=reshape([1,1, &
                                                1,2, &
                                                1,3, &
                                                1,4, &
                                                1,5, &
                                                1,6, &
                                                1,7],&
                                               [2,7])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I4P), intent(inout), allocatable :: var(:,:,:,:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,7)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I2P_1D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I2P, rank 1).

     use penf
 integer(I2P), allocatable :: a(:)
 integer(I4P)              :: ulb(2)=[1,1]
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I2P), intent(inout), allocatable :: var(:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I2P_2D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I2P, rank 2).

     use penf
 integer(I2P), allocatable :: a(:,:)
 integer(I4P)              :: ulb(2,2)=reshape([1,1, &
                                                1,2],&
                                               [2,2])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I2P), intent(inout), allocatable :: var(:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,2)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I2P_3D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I2P, rank 3).

     use penf
 integer(I2P), allocatable :: a(:,:,:)
 integer(I4P)              :: ulb(2,3)=reshape([1,1, &
                                                1,2, &
                                                1,3],&
                                               [2,3])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I2P), intent(inout), allocatable :: var(:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,3)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I2P_4D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I2P, rank 4).

     use penf
 integer(I2P), allocatable :: a(:,:,:,:)
 integer(I4P)              :: ulb(2,4)=reshape([1,1, &
                                                1,2, &
                                                1,3, &
                                                1,4],&
                                               [2,4])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I2P), intent(inout), allocatable :: var(:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,4)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I2P_5D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I2P, rank 5).

     use penf
 integer(I2P), allocatable :: a(:,:,:,:,:)
 integer(I4P)              :: ulb(2,5)=reshape([1,1, &
                                                1,2, &
                                                1,3, &
                                                1,4, &
                                                1,5],&
                                               [2,5])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I2P), intent(inout), allocatable :: var(:,:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,5)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I2P_6D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I2P, rank 6).

     use penf
 integer(I2P), allocatable :: a(:,:,:,:,:,:)
 integer(I4P)              :: ulb(2,6)=reshape([1,1, &
                                                1,2, &
                                                1,3, &
                                                1,4, &
                                                1,5, &
                                                1,6],&
                                               [2,6])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I2P), intent(inout), allocatable :: var(:,:,:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,6)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I2P_7D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I2P, rank 7).

     use penf
 integer(I2P), allocatable :: a(:,:,:,:,:,:,:)
 integer(I4P)              :: ulb(2,7)=reshape([1,1, &
                                                1,2, &
                                                1,3, &
                                                1,4, &
                                                1,5, &
                                                1,6, &
                                                1,7],&
                                               [2,7])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I2P), intent(inout), allocatable :: var(:,:,:,:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,7)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I1P_1D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I1P, rank 1).

     use penf
 integer(I1P), allocatable :: a(:)
 integer(I4P)              :: ulb(2)=[1,1]
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I1P), intent(inout), allocatable :: var(:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I1P_2D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I1P, rank 2).

     use penf
 integer(I1P), allocatable :: a(:,:)
 integer(I4P)              :: ulb(2,2)=reshape([1,1, &
                                                1,2],&
                                               [2,2])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I1P), intent(inout), allocatable :: var(:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,2)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I1P_3D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I1P, rank 3).

     use penf
 integer(I1P), allocatable :: a(:,:,:)
 integer(I4P)              :: ulb(2,3)=reshape([1,1, &
                                                1,2, &
                                                1,3],&
                                               [2,3])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I1P), intent(inout), allocatable :: var(:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,3)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I1P_4D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I1P, rank 4).

     use penf
 integer(I1P), allocatable :: a(:,:,:,:)
 integer(I4P)              :: ulb(2,4)=reshape([1,1, &
                                                1,2, &
                                                1,3, &
                                                1,4],&
                                               [2,4])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I1P), intent(inout), allocatable :: var(:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,4)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I1P_5D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I1P, rank 5).

     use penf
 integer(I1P), allocatable :: a(:,:,:,:,:)
 integer(I4P)              :: ulb(2,5)=reshape([1,1, &
                                                1,2, &
                                                1,3, &
                                                1,4, &
                                                1,5],&
                                               [2,5])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I1P), intent(inout), allocatable :: var(:,:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,5)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I1P_6D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I1P, rank 6).

     use penf
 integer(I1P), allocatable :: a(:,:,:,:,:,:)
 integer(I4P)              :: ulb(2,6)=reshape([1,1, &
                                                1,2, &
                                                1,3, &
                                                1,4, &
                                                1,5, &
                                                1,6],&
                                               [2,6])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I1P), intent(inout), allocatable :: var(:,:,:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,6)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine alloc_var_I1P_7D(var, ulb, file_unit, msg, verbose)

    Allocate CPU variable with memory checking (kind I1P, rank 7).

     use penf
 integer(I1P), allocatable :: a(:,:,:,:,:,:,:)
 integer(I4P)              :: ulb(2,7)=reshape([1,1, &
                                                1,2, &
                                                1,3, &
                                                1,4, &
                                                1,5, &
                                                1,6, &
                                                1,7],&
                                               [2,7])
 open(unit=666, file='doctest-mem.log')
 call allocate_variable(a, ulb, file_unit=666, verbose=.true.)
 close(666, status='delete')
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I1P), intent(inout), allocatable :: var(:,:,:,:,:,:,:)

    Varibale to be allocate on CPU.
    integer(kind=I4P), intent(in) :: ulb(2,7)

    Upper/lower bounds of variable.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

public interface assign_allocatable

Assign CPU variable with memory checking.

  • private subroutine assign_allocatable_R8P_1D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind R8P, rank 1). Variable is returned not allocated if right hand side is not allocated.

     use penf
 real(R8P), allocatable :: a(:), b(:)
 allocate(b(1:1))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R8P), intent(inout), allocatable :: lhs(:)

    Left hand side of assignement.
    real(kind=R8P), intent(in), allocatable :: rhs(:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_R8P_2D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind R8P, rank 2). Variable is returned not allocated if right hand side is not allocated.

     use penf
 real(R8P), allocatable :: a(:,:), b(:,:)
 allocate(b(1:1,1:2))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R8P), intent(inout), allocatable :: lhs(:,:)

    Left hand side of assignement.
    real(kind=R8P), intent(in), allocatable :: rhs(:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_R8P_3D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind R8P, rank 3). Variable is returned not allocated if right hand side is not allocated.

     use penf
 real(R8P), allocatable :: a(:,:,:), b(:,:,:)
 allocate(b(1:1,1:2,1:3))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R8P), intent(inout), allocatable :: lhs(:,:,:)

    Left hand side of assignement.
    real(kind=R8P), intent(in), allocatable :: rhs(:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_R8P_4D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind R8P, rank 4). Variable is returned not allocated if right hand side is not allocated.

     use penf
 real(R8P), allocatable :: a(:,:,:,:), b(:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R8P), intent(inout), allocatable :: lhs(:,:,:,:)

    Left hand side of assignement.
    real(kind=R8P), intent(in), allocatable :: rhs(:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_R8P_5D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind R8P, rank 5). Variable is returned not allocated if right hand side is not allocated.

     use penf
 real(R8P), allocatable :: a(:,:,:,:,:), b(:,:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4,1:5))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R8P), intent(inout), allocatable :: lhs(:,:,:,:,:)

    Left hand side of assignement.
    real(kind=R8P), intent(in), allocatable :: rhs(:,:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_R8P_6D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind R8P, rank 6). Variable is returned not allocated if right hand side is not allocated.

     use penf
 real(R8P), allocatable :: a(:,:,:,:,:,:), b(:,:,:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4,1:5,1:6))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R8P), intent(inout), allocatable :: lhs(:,:,:,:,:,:)

    Left hand side of assignement.
    real(kind=R8P), intent(in), allocatable :: rhs(:,:,:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_R8P_7D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind R8P, rank 7). Variable is returned not allocated if right hand side is not allocated.

     use penf
 real(R8P), allocatable :: a(:,:,:,:,:,:,:), b(:,:,:,:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4,1:5,1:6,1:7))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R8P), intent(inout), allocatable :: lhs(:,:,:,:,:,:,:)

    Left hand side of assignement.
    real(kind=R8P), intent(in), allocatable :: rhs(:,:,:,:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_R4P_1D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind R4P, rank 1). Variable is returned not allocated if right hand side is not allocated.

     use penf
 real(R4P), allocatable :: a(:), b(:)
 allocate(b(1:1))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R4P), intent(inout), allocatable :: lhs(:)

    Left hand side of assignement.
    real(kind=R4P), intent(in), allocatable :: rhs(:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_R4P_2D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind R4P, rank 2). Variable is returned not allocated if right hand side is not allocated.

     use penf
 real(R4P), allocatable :: a(:,:), b(:,:)
 allocate(b(1:1,1:2))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R4P), intent(inout), allocatable :: lhs(:,:)

    Left hand side of assignement.
    real(kind=R4P), intent(in), allocatable :: rhs(:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_R4P_3D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind R4P, rank 3). Variable is returned not allocated if right hand side is not allocated.

     use penf
 real(R4P), allocatable :: a(:,:,:), b(:,:,:)
 allocate(b(1:1,1:2,1:3))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R4P), intent(inout), allocatable :: lhs(:,:,:)

    Left hand side of assignement.
    real(kind=R4P), intent(in), allocatable :: rhs(:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_R4P_4D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind R4P, rank 4). Variable is returned not allocated if right hand side is not allocated.

     use penf
 real(R4P), allocatable :: a(:,:,:,:), b(:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R4P), intent(inout), allocatable :: lhs(:,:,:,:)

    Left hand side of assignement.
    real(kind=R4P), intent(in), allocatable :: rhs(:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_R4P_5D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind R4P, rank 5). Variable is returned not allocated if right hand side is not allocated.

     use penf
 real(R4P), allocatable :: a(:,:,:,:,:), b(:,:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4,1:5))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R4P), intent(inout), allocatable :: lhs(:,:,:,:,:)

    Left hand side of assignement.
    real(kind=R4P), intent(in), allocatable :: rhs(:,:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_R4P_6D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind R4P, rank 6). Variable is returned not allocated if right hand side is not allocated.

     use penf
 real(R4P), allocatable :: a(:,:,:,:,:,:), b(:,:,:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4,1:5,1:6))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R4P), intent(inout), allocatable :: lhs(:,:,:,:,:,:)

    Left hand side of assignement.
    real(kind=R4P), intent(in), allocatable :: rhs(:,:,:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_R4P_7D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind R4P, rank 7). Variable is returned not allocated if right hand side is not allocated.

     use penf
 real(R4P), allocatable :: a(:,:,:,:,:,:,:), b(:,:,:,:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4,1:5,1:6,1:7))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    real(kind=R4P), intent(inout), allocatable :: lhs(:,:,:,:,:,:,:)

    Left hand side of assignement.
    real(kind=R4P), intent(in), allocatable :: rhs(:,:,:,:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I8P_1D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I8P, rank 1). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I8P), allocatable :: a(:), b(:)
 allocate(b(1:1))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I8P), intent(inout), allocatable :: lhs(:)

    Left hand side of assignement.
    integer(kind=I8P), intent(in), allocatable :: rhs(:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I8P_2D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I8P, rank 2). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I8P), allocatable :: a(:,:), b(:,:)
 allocate(b(1:1,1:2))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I8P), intent(inout), allocatable :: lhs(:,:)

    Left hand side of assignement.
    integer(kind=I8P), intent(in), allocatable :: rhs(:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I8P_3D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I8P, rank 3). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I8P), allocatable :: a(:,:,:), b(:,:,:)
 allocate(b(1:1,1:2,1:3))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I8P), intent(inout), allocatable :: lhs(:,:,:)

    Left hand side of assignement.
    integer(kind=I8P), intent(in), allocatable :: rhs(:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I8P_4D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I8P, rank 4). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I8P), allocatable :: a(:,:,:,:), b(:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I8P), intent(inout), allocatable :: lhs(:,:,:,:)

    Left hand side of assignement.
    integer(kind=I8P), intent(in), allocatable :: rhs(:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I8P_5D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I8P, rank 5). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I8P), allocatable :: a(:,:,:,:,:), b(:,:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4,1:5))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I8P), intent(inout), allocatable :: lhs(:,:,:,:,:)

    Left hand side of assignement.
    integer(kind=I8P), intent(in), allocatable :: rhs(:,:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I8P_6D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I8P, rank 6). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I8P), allocatable :: a(:,:,:,:,:,:), b(:,:,:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4,1:5,1:6))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I8P), intent(inout), allocatable :: lhs(:,:,:,:,:,:)

    Left hand side of assignement.
    integer(kind=I8P), intent(in), allocatable :: rhs(:,:,:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I8P_7D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I8P, rank 7). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I8P), allocatable :: a(:,:,:,:,:,:,:), b(:,:,:,:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4,1:5,1:6,1:7))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I8P), intent(inout), allocatable :: lhs(:,:,:,:,:,:,:)

    Left hand side of assignement.
    integer(kind=I8P), intent(in), allocatable :: rhs(:,:,:,:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I4P_1D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I4P, rank 1). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I4P), allocatable :: a(:), b(:)
 allocate(b(1:1))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I4P), intent(inout), allocatable :: lhs(:)

    Left hand side of assignement.
    integer(kind=I4P), intent(in), allocatable :: rhs(:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I4P_2D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I4P, rank 2). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I4P), allocatable :: a(:,:), b(:,:)
 allocate(b(1:1,1:2))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I4P), intent(inout), allocatable :: lhs(:,:)

    Left hand side of assignement.
    integer(kind=I4P), intent(in), allocatable :: rhs(:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I4P_3D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I4P, rank 3). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I4P), allocatable :: a(:,:,:), b(:,:,:)
 allocate(b(1:1,1:2,1:3))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I4P), intent(inout), allocatable :: lhs(:,:,:)

    Left hand side of assignement.
    integer(kind=I4P), intent(in), allocatable :: rhs(:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I4P_4D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I4P, rank 4). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I4P), allocatable :: a(:,:,:,:), b(:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I4P), intent(inout), allocatable :: lhs(:,:,:,:)

    Left hand side of assignement.
    integer(kind=I4P), intent(in), allocatable :: rhs(:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I4P_5D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I4P, rank 5). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I4P), allocatable :: a(:,:,:,:,:), b(:,:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4,1:5))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I4P), intent(inout), allocatable :: lhs(:,:,:,:,:)

    Left hand side of assignement.
    integer(kind=I4P), intent(in), allocatable :: rhs(:,:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I4P_6D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I4P, rank 6). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I4P), allocatable :: a(:,:,:,:,:,:), b(:,:,:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4,1:5,1:6))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I4P), intent(inout), allocatable :: lhs(:,:,:,:,:,:)

    Left hand side of assignement.
    integer(kind=I4P), intent(in), allocatable :: rhs(:,:,:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I4P_7D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I4P, rank 7). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I4P), allocatable :: a(:,:,:,:,:,:,:), b(:,:,:,:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4,1:5,1:6,1:7))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I4P), intent(inout), allocatable :: lhs(:,:,:,:,:,:,:)

    Left hand side of assignement.
    integer(kind=I4P), intent(in), allocatable :: rhs(:,:,:,:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I2P_1D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I2P, rank 1). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I2P), allocatable :: a(:), b(:)
 allocate(b(1:1))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I2P), intent(inout), allocatable :: lhs(:)

    Left hand side of assignement.
    integer(kind=I2P), intent(in), allocatable :: rhs(:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I2P_2D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I2P, rank 2). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I2P), allocatable :: a(:,:), b(:,:)
 allocate(b(1:1,1:2))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I2P), intent(inout), allocatable :: lhs(:,:)

    Left hand side of assignement.
    integer(kind=I2P), intent(in), allocatable :: rhs(:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I2P_3D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I2P, rank 3). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I2P), allocatable :: a(:,:,:), b(:,:,:)
 allocate(b(1:1,1:2,1:3))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I2P), intent(inout), allocatable :: lhs(:,:,:)

    Left hand side of assignement.
    integer(kind=I2P), intent(in), allocatable :: rhs(:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I2P_4D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I2P, rank 4). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I2P), allocatable :: a(:,:,:,:), b(:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I2P), intent(inout), allocatable :: lhs(:,:,:,:)

    Left hand side of assignement.
    integer(kind=I2P), intent(in), allocatable :: rhs(:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I2P_5D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I2P, rank 5). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I2P), allocatable :: a(:,:,:,:,:), b(:,:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4,1:5))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I2P), intent(inout), allocatable :: lhs(:,:,:,:,:)

    Left hand side of assignement.
    integer(kind=I2P), intent(in), allocatable :: rhs(:,:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I2P_6D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I2P, rank 6). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I2P), allocatable :: a(:,:,:,:,:,:), b(:,:,:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4,1:5,1:6))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I2P), intent(inout), allocatable :: lhs(:,:,:,:,:,:)

    Left hand side of assignement.
    integer(kind=I2P), intent(in), allocatable :: rhs(:,:,:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I2P_7D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I2P, rank 7). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I2P), allocatable :: a(:,:,:,:,:,:,:), b(:,:,:,:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4,1:5,1:6,1:7))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I2P), intent(inout), allocatable :: lhs(:,:,:,:,:,:,:)

    Left hand side of assignement.
    integer(kind=I2P), intent(in), allocatable :: rhs(:,:,:,:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I1P_1D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I1P, rank 1). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I1P), allocatable :: a(:), b(:)
 allocate(b(1:1))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I1P), intent(inout), allocatable :: lhs(:)

    Left hand side of assignement.
    integer(kind=I1P), intent(in), allocatable :: rhs(:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I1P_2D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I1P, rank 2). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I1P), allocatable :: a(:,:), b(:,:)
 allocate(b(1:1,1:2))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I1P), intent(inout), allocatable :: lhs(:,:)

    Left hand side of assignement.
    integer(kind=I1P), intent(in), allocatable :: rhs(:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I1P_3D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I1P, rank 3). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I1P), allocatable :: a(:,:,:), b(:,:,:)
 allocate(b(1:1,1:2,1:3))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I1P), intent(inout), allocatable :: lhs(:,:,:)

    Left hand side of assignement.
    integer(kind=I1P), intent(in), allocatable :: rhs(:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I1P_4D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I1P, rank 4). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I1P), allocatable :: a(:,:,:,:), b(:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I1P), intent(inout), allocatable :: lhs(:,:,:,:)

    Left hand side of assignement.
    integer(kind=I1P), intent(in), allocatable :: rhs(:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I1P_5D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I1P, rank 5). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I1P), allocatable :: a(:,:,:,:,:), b(:,:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4,1:5))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I1P), intent(inout), allocatable :: lhs(:,:,:,:,:)

    Left hand side of assignement.
    integer(kind=I1P), intent(in), allocatable :: rhs(:,:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I1P_6D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I1P, rank 6). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I1P), allocatable :: a(:,:,:,:,:,:), b(:,:,:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4,1:5,1:6))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I1P), intent(inout), allocatable :: lhs(:,:,:,:,:,:)

    Left hand side of assignement.
    integer(kind=I1P), intent(in), allocatable :: rhs(:,:,:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

  • private subroutine assign_allocatable_I1P_7D(lhs, rhs, file_unit, msg, verbose)

    Assign CPU variable with memory checking (kind I1P, rank 7). Variable is returned not allocated if right hand side is not allocated.

     use penf
 integer(I1P), allocatable :: a(:,:,:,:,:,:,:), b(:,:,:,:,:,:,:)
 allocate(b(1:1,1:2,1:3,1:4,1:5,1:6,1:7))
 call assign_allocatable(a, b)
 print*, allocated(a)

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=I1P), intent(inout), allocatable :: lhs(:,:,:,:,:,:,:)

    Left hand side of assignement.
    integer(kind=I1P), intent(in), allocatable :: rhs(:,:,:,:,:,:,:)

    Right hand side of assignement.
    integer(kind=I4P), intent(in), optional :: file_unit

    File unit for verbose output.
    character(len=*), intent(in), optional :: msg

    Message to be printed in verbose mode.
    logical, intent(in), optional :: verbose

    Flag to activate verbose mode.

Subroutines

private subroutine alloc_var_R16P_1D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R16P, rank 1).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R16P), intent(inout), allocatable :: var(:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_R16P_2D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R16P, rank 2).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R16P), intent(inout), allocatable :: var(:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,2)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_R16P_3D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R16P, rank 3).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R16P), intent(inout), allocatable :: var(:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,3)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_R16P_4D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R16P, rank 4).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R16P), intent(inout), allocatable :: var(:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,4)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_R16P_5D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R16P, rank 5).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R16P), intent(inout), allocatable :: var(:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,5)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_R16P_6D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R16P, rank 6).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R16P), intent(inout), allocatable :: var(:,:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,6)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_R16P_7D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R16P, rank 6).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R16P), intent(inout), allocatable :: var(:,:,:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,7)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_R8P_1D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R8P, rank 1).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R8P), intent(inout), allocatable :: var(:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_R8P_2D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R8P, rank 2).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R8P), intent(inout), allocatable :: var(:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,2)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_R8P_3D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R8P, rank 3).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R8P), intent(inout), allocatable :: var(:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,3)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_R8P_4D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R8P, rank 4).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R8P), intent(inout), allocatable :: var(:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,4)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_R8P_5D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R8P, rank 5).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R8P), intent(inout), allocatable :: var(:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,5)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_R8P_6D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R8P, rank 6).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R8P), intent(inout), allocatable :: var(:,:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,6)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_R8P_7D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R8P, rank 6).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R8P), intent(inout), allocatable :: var(:,:,:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,7)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_R4P_1D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R4P, rank 1).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R4P), intent(inout), allocatable :: var(:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_R4P_2D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R4P, rank 2).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R4P), intent(inout), allocatable :: var(:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,2)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_R4P_3D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R4P, rank 3).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R4P), intent(inout), allocatable :: var(:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,3)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_R4P_4D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R4P, rank 4).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R4P), intent(inout), allocatable :: var(:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,4)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_R4P_5D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R4P, rank 5).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R4P), intent(inout), allocatable :: var(:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,5)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_R4P_6D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R4P, rank 6).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R4P), intent(inout), allocatable :: var(:,:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,6)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_R4P_7D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind R4P, rank 6).

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R4P), intent(inout), allocatable :: var(:,:,:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,7)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I8P_1D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I8P, rank 1).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I8P), intent(inout), allocatable :: var(:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I8P_2D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I8P, rank 2).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I8P), intent(inout), allocatable :: var(:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,2)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I8P_3D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I8P, rank 3).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I8P), intent(inout), allocatable :: var(:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,3)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I8P_4D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I8P, rank 4).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I8P), intent(inout), allocatable :: var(:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,4)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I8P_5D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I8P, rank 5).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I8P), intent(inout), allocatable :: var(:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,5)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I8P_6D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I8P, rank 6).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I8P), intent(inout), allocatable :: var(:,:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,6)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I8P_7D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I8P, rank 7).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I8P), intent(inout), allocatable :: var(:,:,:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,7)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I4P_1D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I4P, rank 1).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I4P), intent(inout), allocatable :: var(:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I4P_2D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I4P, rank 2).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I4P), intent(inout), allocatable :: var(:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,2)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I4P_3D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I4P, rank 3).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I4P), intent(inout), allocatable :: var(:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,3)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I4P_4D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I4P, rank 4).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I4P), intent(inout), allocatable :: var(:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,4)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I4P_5D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I4P, rank 5).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I4P), intent(inout), allocatable :: var(:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,5)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I4P_6D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I4P, rank 6).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I4P), intent(inout), allocatable :: var(:,:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,6)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I4P_7D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I4P, rank 7).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I4P), intent(inout), allocatable :: var(:,:,:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,7)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I2P_1D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I2P, rank 1).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I2P), intent(inout), allocatable :: var(:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I2P_2D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I2P, rank 2).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I2P), intent(inout), allocatable :: var(:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,2)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I2P_3D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I2P, rank 3).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I2P), intent(inout), allocatable :: var(:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,3)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I2P_4D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I2P, rank 4).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I2P), intent(inout), allocatable :: var(:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,4)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I2P_5D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I2P, rank 5).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I2P), intent(inout), allocatable :: var(:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,5)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I2P_6D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I2P, rank 6).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I2P), intent(inout), allocatable :: var(:,:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,6)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I2P_7D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I2P, rank 7).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I2P), intent(inout), allocatable :: var(:,:,:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,7)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I1P_1D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I1P, rank 1).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I1P), intent(inout), allocatable :: var(:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I1P_2D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I1P, rank 2).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I1P), intent(inout), allocatable :: var(:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,2)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I1P_3D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I1P, rank 3).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I1P), intent(inout), allocatable :: var(:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,3)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I1P_4D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I1P, rank 4).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I1P), intent(inout), allocatable :: var(:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,4)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I1P_5D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I1P, rank 5).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I1P), intent(inout), allocatable :: var(:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,5)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I1P_6D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I1P, rank 6).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I1P), intent(inout), allocatable :: var(:,:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,6)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine alloc_var_I1P_7D(var, ulb, file_unit, msg, verbose)

Allocate CPU variable with memory checking (kind I1P, rank 7).

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I1P), intent(inout), allocatable :: var(:,:,:,:,:,:,:)

Varibale to be allocate on CPU.
integer(kind=I4P), intent(in) :: ulb(2,7)

Upper/lower bounds of variable.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R16P_1D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R16P, rank 1). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R16P), intent(inout), allocatable :: lhs(:)

Left hand side of assignement.
real(kind=R16P), intent(in), allocatable :: rhs(:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R16P_2D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R16P, rank 2). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R16P), intent(inout), allocatable :: lhs(:,:)

Left hand side of assignement.
real(kind=R16P), intent(in), allocatable :: rhs(:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R16P_3D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R16P, rank 3). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R16P), intent(inout), allocatable :: lhs(:,:,:)

Left hand side of assignement.
real(kind=R16P), intent(in), allocatable :: rhs(:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R16P_4D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R16P, rank 4). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R16P), intent(inout), allocatable :: lhs(:,:,:,:)

Left hand side of assignement.
real(kind=R16P), intent(in), allocatable :: rhs(:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R16P_5D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R16P, rank 5). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R16P), intent(inout), allocatable :: lhs(:,:,:,:,:)

Left hand side of assignement.
real(kind=R16P), intent(in), allocatable :: rhs(:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R16P_6D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R16P, rank 6). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R16P), intent(inout), allocatable :: lhs(:,:,:,:,:,:)

Left hand side of assignement.
real(kind=R16P), intent(in), allocatable :: rhs(:,:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R16P_7D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R16P, rank 7). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R16P), intent(inout), allocatable :: lhs(:,:,:,:,:,:,:)

Left hand side of assignement.
real(kind=R16P), intent(in), allocatable :: rhs(:,:,:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R8P_1D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R8P, rank 1). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R8P), intent(inout), allocatable :: lhs(:)

Left hand side of assignement.
real(kind=R8P), intent(in), allocatable :: rhs(:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R8P_2D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R8P, rank 2). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R8P), intent(inout), allocatable :: lhs(:,:)

Left hand side of assignement.
real(kind=R8P), intent(in), allocatable :: rhs(:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R8P_3D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R8P, rank 3). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R8P), intent(inout), allocatable :: lhs(:,:,:)

Left hand side of assignement.
real(kind=R8P), intent(in), allocatable :: rhs(:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R8P_4D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R8P, rank 4). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R8P), intent(inout), allocatable :: lhs(:,:,:,:)

Left hand side of assignement.
real(kind=R8P), intent(in), allocatable :: rhs(:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R8P_5D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R8P, rank 5). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R8P), intent(inout), allocatable :: lhs(:,:,:,:,:)

Left hand side of assignement.
real(kind=R8P), intent(in), allocatable :: rhs(:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R8P_6D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R8P, rank 6). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R8P), intent(inout), allocatable :: lhs(:,:,:,:,:,:)

Left hand side of assignement.
real(kind=R8P), intent(in), allocatable :: rhs(:,:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R8P_7D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R8P, rank 7). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R8P), intent(inout), allocatable :: lhs(:,:,:,:,:,:,:)

Left hand side of assignement.
real(kind=R8P), intent(in), allocatable :: rhs(:,:,:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R4P_1D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R4P, rank 1). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R4P), intent(inout), allocatable :: lhs(:)

Left hand side of assignement.
real(kind=R4P), intent(in), allocatable :: rhs(:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R4P_2D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R4P, rank 2). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R4P), intent(inout), allocatable :: lhs(:,:)

Left hand side of assignement.
real(kind=R4P), intent(in), allocatable :: rhs(:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R4P_3D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R4P, rank 3). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R4P), intent(inout), allocatable :: lhs(:,:,:)

Left hand side of assignement.
real(kind=R4P), intent(in), allocatable :: rhs(:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R4P_4D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R4P, rank 4). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R4P), intent(inout), allocatable :: lhs(:,:,:,:)

Left hand side of assignement.
real(kind=R4P), intent(in), allocatable :: rhs(:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R4P_5D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R4P, rank 5). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R4P), intent(inout), allocatable :: lhs(:,:,:,:,:)

Left hand side of assignement.
real(kind=R4P), intent(in), allocatable :: rhs(:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R4P_6D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R4P, rank 6). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R4P), intent(inout), allocatable :: lhs(:,:,:,:,:,:)

Left hand side of assignement.
real(kind=R4P), intent(in), allocatable :: rhs(:,:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_R4P_7D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind R4P, rank 7). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
real(kind=R4P), intent(inout), allocatable :: lhs(:,:,:,:,:,:,:)

Left hand side of assignement.
real(kind=R4P), intent(in), allocatable :: rhs(:,:,:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I8P_1D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I8P, rank 1). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I8P), intent(inout), allocatable :: lhs(:)

Left hand side of assignement.
integer(kind=I8P), intent(in), allocatable :: rhs(:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I8P_2D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I8P, rank 2). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I8P), intent(inout), allocatable :: lhs(:,:)

Left hand side of assignement.
integer(kind=I8P), intent(in), allocatable :: rhs(:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I8P_3D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I8P, rank 3). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I8P), intent(inout), allocatable :: lhs(:,:,:)

Left hand side of assignement.
integer(kind=I8P), intent(in), allocatable :: rhs(:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I8P_4D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I8P, rank 4). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I8P), intent(inout), allocatable :: lhs(:,:,:,:)

Left hand side of assignement.
integer(kind=I8P), intent(in), allocatable :: rhs(:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I8P_5D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I8P, rank 5). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I8P), intent(inout), allocatable :: lhs(:,:,:,:,:)

Left hand side of assignement.
integer(kind=I8P), intent(in), allocatable :: rhs(:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I8P_6D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I8P, rank 6). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I8P), intent(inout), allocatable :: lhs(:,:,:,:,:,:)

Left hand side of assignement.
integer(kind=I8P), intent(in), allocatable :: rhs(:,:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I8P_7D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I8P, rank 7). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I8P), intent(inout), allocatable :: lhs(:,:,:,:,:,:,:)

Left hand side of assignement.
integer(kind=I8P), intent(in), allocatable :: rhs(:,:,:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I4P_1D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I4P, rank 1). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I4P), intent(inout), allocatable :: lhs(:)

Left hand side of assignement.
integer(kind=I4P), intent(in), allocatable :: rhs(:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I4P_2D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I4P, rank 2). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I4P), intent(inout), allocatable :: lhs(:,:)

Left hand side of assignement.
integer(kind=I4P), intent(in), allocatable :: rhs(:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I4P_3D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I4P, rank 3). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I4P), intent(inout), allocatable :: lhs(:,:,:)

Left hand side of assignement.
integer(kind=I4P), intent(in), allocatable :: rhs(:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I4P_4D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I4P, rank 4). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I4P), intent(inout), allocatable :: lhs(:,:,:,:)

Left hand side of assignement.
integer(kind=I4P), intent(in), allocatable :: rhs(:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I4P_5D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I4P, rank 5). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I4P), intent(inout), allocatable :: lhs(:,:,:,:,:)

Left hand side of assignement.
integer(kind=I4P), intent(in), allocatable :: rhs(:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I4P_6D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I4P, rank 6). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I4P), intent(inout), allocatable :: lhs(:,:,:,:,:,:)

Left hand side of assignement.
integer(kind=I4P), intent(in), allocatable :: rhs(:,:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I4P_7D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I4P, rank 7). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I4P), intent(inout), allocatable :: lhs(:,:,:,:,:,:,:)

Left hand side of assignement.
integer(kind=I4P), intent(in), allocatable :: rhs(:,:,:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I2P_1D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I2P, rank 1). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I2P), intent(inout), allocatable :: lhs(:)

Left hand side of assignement.
integer(kind=I2P), intent(in), allocatable :: rhs(:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I2P_2D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I2P, rank 2). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I2P), intent(inout), allocatable :: lhs(:,:)

Left hand side of assignement.
integer(kind=I2P), intent(in), allocatable :: rhs(:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I2P_3D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I2P, rank 3). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I2P), intent(inout), allocatable :: lhs(:,:,:)

Left hand side of assignement.
integer(kind=I2P), intent(in), allocatable :: rhs(:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I2P_4D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I2P, rank 4). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I2P), intent(inout), allocatable :: lhs(:,:,:,:)

Left hand side of assignement.
integer(kind=I2P), intent(in), allocatable :: rhs(:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I2P_5D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I2P, rank 5). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I2P), intent(inout), allocatable :: lhs(:,:,:,:,:)

Left hand side of assignement.
integer(kind=I2P), intent(in), allocatable :: rhs(:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I2P_6D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I2P, rank 6). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I2P), intent(inout), allocatable :: lhs(:,:,:,:,:,:)

Left hand side of assignement.
integer(kind=I2P), intent(in), allocatable :: rhs(:,:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I2P_7D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I2P, rank 7). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I2P), intent(inout), allocatable :: lhs(:,:,:,:,:,:,:)

Left hand side of assignement.
integer(kind=I2P), intent(in), allocatable :: rhs(:,:,:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I1P_1D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I1P, rank 1). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I1P), intent(inout), allocatable :: lhs(:)

Left hand side of assignement.
integer(kind=I1P), intent(in), allocatable :: rhs(:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I1P_2D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I1P, rank 2). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I1P), intent(inout), allocatable :: lhs(:,:)

Left hand side of assignement.
integer(kind=I1P), intent(in), allocatable :: rhs(:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I1P_3D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I1P, rank 3). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I1P), intent(inout), allocatable :: lhs(:,:,:)

Left hand side of assignement.
integer(kind=I1P), intent(in), allocatable :: rhs(:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I1P_4D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I1P, rank 4). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I1P), intent(inout), allocatable :: lhs(:,:,:,:)

Left hand side of assignement.
integer(kind=I1P), intent(in), allocatable :: rhs(:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I1P_5D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I1P, rank 5). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I1P), intent(inout), allocatable :: lhs(:,:,:,:,:)

Left hand side of assignement.
integer(kind=I1P), intent(in), allocatable :: rhs(:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I1P_6D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I1P, rank 6). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I1P), intent(inout), allocatable :: lhs(:,:,:,:,:,:)

Left hand side of assignement.
integer(kind=I1P), intent(in), allocatable :: rhs(:,:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

private subroutine assign_allocatable_I1P_7D(lhs, rhs, file_unit, msg, verbose)

Assign CPU variable with memory checking (kind I1P, rank 7). Variable is returned not allocated if right hand side is not allocated.

Read more…

Arguments

Type IntentOptional Attributes Name
integer(kind=I1P), intent(inout), allocatable :: lhs(:,:,:,:,:,:,:)

Left hand side of assignement.
integer(kind=I1P), intent(in), allocatable :: rhs(:,:,:,:,:,:,:)

Right hand side of assignement.
integer(kind=I4P), intent(in), optional :: file_unit

File unit for verbose output.
character(len=*), intent(in), optional :: msg

Message to be printed in verbose mode.
logical, intent(in), optional :: verbose

Flag to activate verbose mode.

public subroutine get_memory_info(mem_free, mem_total)

Get the current CPU-memory status. @note Note Currently implemented only per Unix/Linux based systems. Return -1 if failing. fortran use penf real(R8P), allocatable :: a(:,:,:) integer(I8P) :: mem_free_1, mem_free_2, mem_total logical :: is_present integer(I4P) :: n, i, j, k call get_memory_info(mem_free_1, mem_total) inquire(file='/proc/meminfo', exist=is_present) if (is_present) then n = 800 allocate(a(1:n,1:n,1:n)) else print*, .true. stop endif a = 1._R8P do k=2, n do j=2, n do i=2, n a(i,j,k) = 1._R8P / 2._R8P * exp(a(i-1,j,k)) - a(i-1,j,k) enddo enddo enddo call get_memory_info(mem_free_2, mem_total) print*, mem_free_1 > mem_free_2

Arguments

Type IntentOptional Attributes Name
integer(kind=I8P), intent(out) :: mem_free

Free memory.
integer(kind=I8P), intent(out) :: mem_total

Total memory.

public subroutine save_memory_status(file_name, tag)

Save the current CPU-memory status into a file. File is accessed in append position.

Arguments

Type IntentOptional Attributes Name
character(len=*), intent(in) :: file_name

File name.
character(len=*), intent(in), optional :: tag

Tag of current status.