! ! !
Margreet Nool - 5 years ago 2014-07-04 15:10:21
greta@timor.sen.cwi.nl
install arcos
295 files changed:
↑ Collapse Diff ↑
 
new file 100644
1
 
include 	Makefile.inc
2
 
include 	Makefile.config
3
 

	
4
 
SOURCE_DIR	= src
5
 
FISH90_DIR	= fish90/src
6
 
F90_DIR		= arcos_f90/src
7
 
CONFIG_DIR	= libconfig-1.4.9/lib
8
 

	
9
 
SUBDIRS		= $(F90_DIR) $(FISH90_DIR) $(SOURCE_DIR) $(CONFIG_DIR)
10
 
CLEANDIRS	= $(SUBDIRS:%=clean-%)
11
 

	
12
 
.PHONY:		all allclean $(SUBDIRS) $(CLEANDIRS)
13
 

	
14
 
# Default Target is to build everything
15
 
all: $(SUBDIRS)
16
 
allclean: $(CLEANDIRS) clean
17
 

	
18
 
$(SUBDIRS):
19
 
	$(MAKE) -C $@
20
 

	
21
 
$(CLEANDIRS):
22
 
	$(MAKE) -C $(@:clean-%=%) clean
23
 

	
24
 
clean:
25
 
	$(RM) $(SOURCE_DIR)/*.o ./arcos
26
 

	
27
 

	
 
new file 100644
1
 
# This file defines the Makefile variables that are used to compile
2
 
# the PHARCOS programs and  libraries. Edit this file as needed.
3
 

	
4
 
# The C compiler and compiler options.
5
 

	
6
 
CC		:= gcc
7
 
#CC		:= pgcc
8
 
CFLAGS		= -g -pg -O3
9
 
# CFLAGS	= -openmp -D_GNU_SOURCE -O3 -ipo -openmp-report0 #-gcc-version=400
10
 

	
11
 

	
12
 
# The Fortran 90 compiler and compiler options. Leave empty to
13
 
# disable Fortran 90 support.
14
 

	
15
 
F90 		:= gfortran -I../lib
16
 
#F90		:= pgf90 -g -pg -I../lib
17
 
#F90FLAGS	= -nofor-main -O3 
18
 
F90FLAGS	= -O3 
19
 
FFLAGS		= -O3
20
 
DEBUG_LEVEL	:= 1
21
 
DFLAGS		= -DCOMPILING_HOSTNAME=\"$(HOSTNAME)\" -DDEBUG_LEVEL=1 
22
 

	
23
 
# Search directories for include files and libraries.
24
 

	
25
 
INCLUDEDIR1	= ../include 
26
 
INCLUDEDIR2	= ../fish90/include 
27
 
INCLUDES	= -I $(INCLUDEDIR1) -I $(INCLUDEDIR2)
28
 
LIBDIRS		= 
29
 
INCDIRS		= 
30
 

	
31
 
# Command for creating static library.
32
 

	
33
 
AR		= ar -rcsv
34
 

	
35
 
# Other commands.
36
 

	
37
 
MV		= mv -f
38
 

	
 
new file 100644
1
 
# This file defines common Makefile variables and rules that are used
2
 
# to compile the FISHPACK libraries. Normally, this
3
 
# file does not have to be modified; see the file Makefile.conf.
4
 

	
5
 
# The names of the fishpack libraries.
6
 

	
7
 
FISHPACK_LIB	= libfishpack.a
8
 
FISH90_LIB	= libfish90.a
9
 

	
10
 
# Commands to compile and link C and Fortran 90 code.
11
 

	
12
 
Compile		= $(CC) $(CFLAGS) $(DFLAGS) $(addprefix -I,$(INCDIRS)) \
13
 
		        -o $@ -c $<
14
 

	
15
 
LinkExe		= $(CC) $(addprefix -L,$(LIBDIRS)) -o $@ $^ \
16
 
		        $(F90FLAGS) $(addprefix -l,$(LIBS))
17
 

	
18
 
CompileF90	= $(F90) $(F90FLAGS) $(addprefix -I,$(INCDIRS)) \
19
 
		         -o $@ -c $<
20
 

	
21
 
LinkF90Exe	= $(F90) $(addprefix -L,$(LIBDIRS)) -o $@ $^ \
22
 
		         $(F90FLAGS) $(addprefix -l,$(LIBS))
23
 

	
24
 
CompileF	= $(F90) $(F90FLAGS) $(addprefix -I,$(INCDIRS)) \
25
 
		         -o $@ -c $<
26
 

	
27
 
Compilef	= $(F90) $(FFLAGS) $(addprefix -I,$(INCDIRS)) \
28
 
		         -o $@ -c $<
29
 

	
30
 
# Implicit rules for compiling C and Fortran source files.
31
 

	
32
 
%.o:		%.c
33
 
		$(Compile)
34
 

	
35
 
%.o:		%.f90
36
 
		$(CompileF90)
37
 

	
38
 
%.o:		%.F
39
 
		$(CompileF)
40
 

	
41
 
%.o:		%.f
42
 
		$(Compilef)
43
 

	
 
new file 100644
1
 
To create the executable arcos:
2
 

	
3
 
- first create library libconfig.
4
 
  Go to directory libconfig-1.4.9/lib  and give the following command
5
 
  make all
6
 

	
7
 
- next, return to the root directory pharcos and give the following command
8
 
  make all
9
 

	
10
 
Now you have the executable arcos, which needs the input files from
11
 
directory input. ./arcos also needs an output directory. The name is given in 
12
 
/input/default.cfg by "output_dir". Here we chose directory output. 
13
 

	
14
 
If output does not exist, create this directory:
15
 
make output
16
 

	
17
 
In this directory many files for visualization will be written. For more details see the documentation:
18
 

	
19
 
file:///?????
 
new file 100644
1
 

	
2
 
TOPDIR	:= ../..
3
 

	
4
 
include	$(TOPDIR)/Makefile.config
5
 
include	$(TOPDIR)/Makefile.inc
6
 

	
7
 
.PHONY:	all
8
 

	
9
 
all:	lib
10
 

	
11
 
SRCF	= cdr_advect_diffu_vec.f90 
12
 
SRCC	= cdr_advect_diffu_wrap.c
13
 

	
14
 
INCDIRS	= ../../include
15
 

	
16
 
OBJF	=$(subst .f90,.o,$(SRCF))
17
 
OBJC	=$(subst .c,.o,$(SRCC))
18
 
OBJ := $(OBJF) $(OBJC)
19
 

	
20
 
LIB	=../lib/libarcos.a
21
 

	
22
 
lib : $(LIB)
23
 

	
24
 
$(LIB) : $(OBJ)
25
 
	$(AR) $@ $? 
26
 

	
27
 
clean:
28
 
	rm -f $(LIB) $(OBJ) *~
 
new file 100644
1
 
!> @file cdr_advect_diffu_vec.f90
2
 
!! @brief This code replaces the original c code of cdr_advect_diffu in file
3
 
!!  cdr.c
4
 
!!
5
 
!! @author Margreet Nool
6
 
!!
7
 
!!     The arrays er_array and ez_array are in C stored as
8
 
!!     1D arrays. In the wrapper routine cdr_advect_diffu_wrap.c it is
9
 
!!     checked of their sizes, er_len, ez_len are equal to rmax-by-zmax.
10
 
!!
11
 
!!     Note that these are NOT the r0, z0 we received.  The idea here is that
12
 
!!     RZ(array, r0, z0) will produce the correct result, where the allocated
13
 
!!     array looks like (in the picture, r0, z0 ARE the received ones).
14
 
!!     Note: in the picture there is only one buffer cell, while we actually
15
 
!!     allocate two.
16
 
!!
17
 
!!      +--------------+--------------+...+--------------+--------------+
18
 
!!      |r0 - 1, z0 - 1|              |   |              |              |
19
 
!!      +--------------+--------------+...+--------------+--------------+
20
 
!!      |              |   r0, z0     |   |              |              |
21
 
!!      +--------------+--------------+...+--------------+--------------+
22
 
!!                    ...             |...|             ...
23
 
!!      +--------------+--------------+...+--------------+--------------+
24
 
!!      |              |              |   |r1 - 1, z1 - 1|              |
25
 
!!      +--------------+--------------+...+--------------+--------------+
26
 
!!      |              |              |   |              |    r1, z1    |
27
 
!!      +--------------+--------------+...+--------------+--------------+
28
 
!!
29
 
!!     but the rows z0 +/- 1 and the columns r0 +/- 1 do not belong to the
30
 
!!     physical space and are used only to specify boundary conditions.
31
 
!!
32
 
!!     In the C routines r0, and z0 are zero, and the calculations start 
33
 
!!     at the third element (r0-2, r0-1, r0, ...., r1, r1+1), and
34
 
!!     (z0-2, z0-1, r0, ...., z1, z1+1), respectively. 
35
 
!!     rmax = r1 - r0 + 4 and zmax = z1 - z0 + 4.
36
 
!!-----------------------------------------------
37
 

	
38
 
! subroutine cdr_advect_vec
39
 
! subroutine mat_efield_r
40
 
! subroutine mat_efield_z
41
 
! subroutine mat_cdr_f_ad_r
42
 
! subroutine mat_cdr_f_ad_z
43
 
! subroutine make_vecs_er
44
 

	
45
 
   subroutine cdr_advect_vec(mass,charge,dens_array,d_dens_array, &
46
 
                         er_array,ez_array,diffusion_coeff,dr,dz, &
47
 
                         sprite_module,r0,r1,z0,z1)
48
 
      implicit none
49
 
!     ..
50
 
!     .. Parameters ..
51
 
      double precision,parameter :: ONE  = 1.0D0
52
 
!     ..
53
 
!     .. Dummy Variables ..
54
 
      logical,intent(in)          :: sprite_module
55
 
      integer,intent(in)          :: r0,r1,z0,z1
56
 
      double precision,intent(in) :: charge,dr,dz,mass,diffusion_coeff
57
 
!     ..
58
 
!     .. Dummy Arrays ..
59
 
      double precision,dimension(r0-2:r1+1,z0-2:z1+1),intent(in)  :: &
60
 
                       dens_array,er_array,ez_array
61
 
      double precision,dimension(r0-2:r1+1,z0-2:z1+1),intent(out) :: &
62
 
                       d_dens_array
63
 
!     ..
64
 
!     .. Local Variables ..
65
 
      integer          :: ir,ishift
66
 
      double precision :: cm0,cm,gdz_inv,d_iso0,d_iso
67
 
!     ..
68
 
!     .. Local arrays ..
69
 
      double precision,dimension(r0:r1-1)             :: er_min
70
 
      double precision,dimension(r0+1:r1)             :: er
71
 
      double precision,dimension(z1-z0)               :: d_iso_r
72
 
      double precision,dimension(z1-z0+1)             :: d_iso_z
73
 
      double precision,dimension(r1-r0+1,z1-z0  )     :: mat_r
74
 
      double precision,dimension(r1-r0  ,z1-z0+1)     :: mat_z
75
 
      double precision,dimension(r1-r0+1,z1-z0  )     :: efield_r
76
 
      double precision,dimension(r0:r1-1,z0-1:z1-1)   :: efield_z
77
 
!     ..
78
 
!     .. External subroutines ..
79
 
      external :: mat_efield_r,mat_efield_z,mat_cdr_f_ad_r,mat_cdr_f_ad_z
80
 
!     ..
81
 

	
82
 
      if (mass <= 0) return
83
 
  
84
 
      ! <ISOTROPIC DIFFUSSION>
85
 
      d_iso0 = diffusion_coeff / mass
86
 
      ! </ISOTROPIC DIFFUSION>
87
 

	
88
 
      gdz_inv = ONE / dz
89
 
  
90
 
      cm0 = charge / mass
91
 
      
92
 
      if (.not.sprite_module) then
93
 
        cm = cm0
94
 
        d_iso = d_iso0
95
 
      end if
96
 
  
97
 
!-----------------------------------------------
98
 
!     Increase the values r0, r1, z0 and z1 with 3:
99
 
!     because of 2 buffer cells at the left side and to compensate the C 0
100
 
!-----------------------------------------------
101
 
      ishift = 3
102
 

	
103
 
      ! Compute the electric field in radial direction
104
 
      call mat_efield_r(er_array(r0-1:r1-1,z0:z1-1), &
105
 
                        efield_r,d_iso_r,cm0,d_iso0, &
106
 
                        r0,r1,dz,z0,z1,ishift,dr,sprite_module)
107
 
      ! Calculate the radial advection from left and right 
108
 
      call mat_cdr_f_ad_r(dens_array(r0-2:r1+1,z0:z1-1), &
109
 
                          efield_r(1:r1-r0+1,1:z1-z0),d_iso_r, &
110
 
                          mat_r,r0,r1,z0,z1)
111
 
      ! Add the radial advection 
112
 
      call  make_vecs_er (er_min,er,r0,r1,dr)
113
 
      do ir = r0,r1-1
114
 
         d_dens_array(ir,z0:z1-1) = d_dens_array(ir,z0:z1-1) + &
115
 
                                    er_min(ir) * mat_r(ir-r0+1,1:z1-z0) - &
116
 
                                    er(ir+1)   * mat_r(ir-r0+2,1:z1-z0)
117
 
      end do
118
 

	
119
 
      ! Compute the electric field in axial direction
120
 
      call mat_efield_z(ez_array(r0  :r1-1,z0-1:z1-1), &
121
 
                        efield_z(r0:r1-1,z0-1:z1-1),d_iso_z,cm0,d_iso0, &
122
 
                        r0,r1,dz,z0,z1,ishift,dz,sprite_module)
123
 
      ! Calculate the axial advection from the north and south
124
 
      call mat_cdr_f_ad_z(dens_array(r0  :r1-1,z0-2:z1+1), &
125
 
                          efield_z(r0:r1-1,z0-1:z1-1),d_iso_z, &
126
 
                          mat_z,r0,r1,z0,z1)
127
 
      ! Add the axial advection 
128
 
      d_dens_array(r0:r1-1,z0:z1-1) = d_dens_array(r0:r1-1,z0:z1-1) + &
129
 
                                      gdz_inv * (mat_z(1:,1:z1-z0) - &
130
 
                                                 mat_z(1:,2:z1-z0+1))
131
 

	
132
 
   end subroutine cdr_advect_vec
133
 

	
134
 
   subroutine mat_efield_r(er_array,efield,d_iso,cm0,d_iso0, &
135
 
                           r0,r1,dz,z0,z1,z_shift,dx,sprite_module)
136
 
!     ..
137
 
      implicit none
138
 
!     ..
139
 
!     .. Parameters ..
140
 
      double precision,parameter :: HALF = 0.5D0,ONE  = 1.0D0
141
 
!     ..
142
 
!     .. Dummy Variables ..
143
 
      logical,intent(in)          :: sprite_module
144
 
      integer,intent(in)          :: r0,r1,z0,z1,z_shift
145
 
      double precision,intent(in) :: cm0,d_iso0,dz,dx
146
 
!     ..
147
 
!     .. Dummy Arrays ..
148
 
      double precision,dimension(r1-r0+1,z1-z0),intent(in)  :: er_array
149
 
      double precision,dimension(r1-r0+1,z1-z0),intent(out) :: efield
150
 
      double precision,dimension(z1-z0),intent(out)         :: d_iso
151
 
!     ..
152
 
!     .. Local Variables ..
153
 
      integer                           :: iz
154
 
!     ..
155
 
!     .. Local arrays ..
156
 
      double precision,dimension(z1-z0) :: back_dens_inv,cm
157
 
!-----------------------------------------------
158
 

	
159
 
      ! If the densities are varying...
160
 
      if (sprite_module) then
161
 
         do iz = z0,z1
162
 
            ! spr_density_at(iz) = (iz-z_shift + half) * dz
163
 
            ! back_dens_inv = ONE / spr_density_at
164
 
            back_dens_inv(iz-z0+1) = ONE / ((iz-z_shift + half) * dz)
165
 
         end do
166
 
         cm    = cm0 * back_dens_inv
167
 
         d_iso = d_iso0 * back_dens_inv
168
 
      else
169
 
         back_dens_inv = ONE
170
 
         cm            = cm0
171
 
         d_iso         = d_iso0
172
 
      end if
173
 

	
174
 
      d_iso = d_iso / dx
175
 

	
176
 
      ! efield = cm * er_array
177
 
      do iz = 1,z1-z0
178
 
         efield(:,iz) = cm(iz) * er_array(:,iz)
179
 
      end do
180
 

	
181
 
   end subroutine mat_efield_r
182
 

	
183
 
   subroutine mat_efield_z (ez_array,efield,d_iso,cm0,d_iso0, &
184
 
                            r0,r1,dz,z0,z1,z_shift,dx,sprite_module)
185
 
!     ..
186
 
      implicit none
187
 
!     ..
188
 
!     .. Parameters ..
189
 
      double precision,parameter :: HALF = 0.5D0,ONE  = 1.0D0
190
 
!     ..
191
 
!     .. Dummy Variables ..
192
 
      logical,intent(in)          :: sprite_module
193
 
      integer,intent(in)          :: r0,r1,z0,z1,z_shift
194
 
      double precision,intent(in) :: cm0,d_iso0,dz,dx
195
 
!     ..
196
 
!     .. Dummy Arrays ..
197
 
      double precision,dimension(r0:r1-1,z0-1:z1-1),intent(in)  :: ez_array
198
 
      double precision,dimension(r0:r1-1,z0-1:z1-1),intent(out) :: efield
199
 
      double precision,dimension(z0-1:z1-1),intent(out)     :: d_iso
200
 
!     ..
201
 
!     .. Local Variables ..
202
 
      integer                               :: iz
203
 
!     ..
204
 
!     .. Local arrays ..
205
 
      double precision,dimension(z0-1:z1-1) :: back_dens_inv,cm
206
 
!     ..
207
 
!-----------------------------------------------
208
 

	
209
 
      ! If the densities are varying...
210
 
      if (sprite_module) then
211
 
         do iz = z0-1,z1+1
212
 
            ! spr_density_at(iz) = (iz-z_shift + half) * dz
213
 
            ! back_dens_inv = ONE / spr_density_at
214
 
            back_dens_inv(iz) = ONE / ((iz-z_shift - half) * dz)
215
 
         end do
216
 
         cm    = cm0 * back_dens_inv
217
 
         d_iso = d_iso0 * back_dens_inv
218
 
      else
219
 
         back_dens_inv = ONE
220
 
         cm            = cm0
221
 
         d_iso         = d_iso0
222
 
      end if
223
 

	
224
 
      d_iso = d_iso / dx
225
 

	
226
 
      ! efield = cm * ez_array
227
 
      do iz = z0-1,z1-1
228
 
         efield(:,iz) = cm(iz) * ez_array(:,iz)
229
 
      end do
230
 

	
231
 
   end subroutine mat_efield_z
232
 

	
233
 
   subroutine mat_cdr_f_ad_r(data_array,efield,d_iso,mat_r,r0,r1,z0,z1)
234
 
!     ..
235
 
      implicit none
236
 
!     ..
237
 
!     .. Parameters ..
238
 
      double precision,parameter :: ZERO = 0.0D0,HALF = 0.5D0, &
239
 
                                    ONE  = 1.0D0,THREE = 3.0D0, &
240
 
                                    verysmall = 1.0e-20
241
 
!     ..
242
 
!     .. Dummy Variables ..
243
 
      integer,intent(in) :: r0,r1,z0,z1
244
 
!     ..
245
 
!     .. Dummy Arrays ..
246
 
      double precision,dimension(z1-z0),intent(in)          :: d_iso
247
 
      double precision,dimension(r1-r0+1,z1-z0),intent(in)  :: efield
248
 
      double precision,dimension(r1-r0+4,z1-z0),intent(in)  :: data_array
249
 
      double precision,dimension(r1-r0+1,z1-z0),intent(out) :: mat_r
250
 
!     ..
251
 
!     .. Local Variables ..
252
 
      integer            :: iz,length
253
 
!     ..
254
 
!     .. Local arrays ..
255
 
      double precision,dimension(r1-r0+1,z1-z0) :: aux,psi_p
256
 
      double precision,dimension(r1-r0+3,z1-z0) :: mat_diff
257
 
!     ..
258
 
!-----------------------------------------------
259
 
      length = r1 - r0 + 1
260
 
      mat_diff(1:length+2,:) = data_array(2:length+3,:) - &
261
 
                               data_array(1:length+2,:)
262
 

	
263
 
      where (abs(mat_diff(2:length+1,:)) > verysmall)
264
 
          where (efield>=ZERO)
265
 
            ! p_min  =data_array(ir-k1,iz-k2)
266
 
            ! p      =data_array(ir,iz)
267
 
            ! p_plus =data_array(ir+k1,iz+k2)
268
 
   
269
 
             psi_p = mat_diff(1:length,:) / mat_diff(2:length+1,:)
270
 
         elsewhere (efield<ZERO)
271
 
            ! p       =data_array(ir,iz)
272
 
            ! p_plus  =data_array(ir+  k1,iz+  k2)
273
 
            ! p_2plus =data_array(ir+2*k1,iz+2*k2)
274
 
   
275
 
             psi_p = mat_diff(3:length+2,:) / mat_diff(2:length+1,:) 
276
 
         end where
277
 
         where (psi_p <= ZERO)
278
 
            ! psi_p = psi_MN (psi_p)
279
 
            psi_p = ZERO
280
 
         elsewhere (psi_p >= 4)
281
 
            psi_p = ONE
282
 
         elsewhere (psi_p >= 0.4)
283
 
            psi_p = (ONE + HALF * psi_p) / THREE
284
 
         end where
285
 
      elsewhere  ! abs(mat_diff(2:length+1,:)) < verysmall
286
 
         psi_p = -ONE
287
 
      end where
288
 

	
289
 
      ! sigmasigma is (sigma_{i+1,j} - sigma_{i,j})*/
290
 
      ! sigmasigma = p - p_plus 
291
 
      aux = psi_p * mat_diff(2:length+1,:)
292
 
      ! aux = p + psi_p * sigmasigma
293
 
      where (efield>=ZERO)
294
 
         aux = data_array(2:length+1,:) + aux
295
 
      elsewhere
296
 
         aux = data_array(3:length+2,:) - aux
297
 
      end where
298
 

	
299
 
      ! aux = efield * (p + psi_p * sigmasigma)
300
 
      aux = aux * efield
301
 
      do iz = 1,z1-z0
302
 
         ! mat_r = d_iso * sigmasigma
303
 
         mat_r(1:length,iz) = d_iso(iz) * mat_diff(2:length+1,iz)
304
 
      end do
305
 
      ! mat_r =  efield * (p + psi_p * sigmasigma) + d_iso * sigmasigma
306
 
      mat_r = aux - mat_r
307
 

	
308
 
   end subroutine mat_cdr_f_ad_r
309
 

	
310
 
   subroutine mat_cdr_f_ad_z(data_array,efield,d_iso,mat_z,r0,r1,z0,z1)
311
 
!     ..
312
 
      implicit none
313
 
!     ..
314
 
!     .. Parameters ..
315
 
      double precision,parameter :: ZERO = 0.0D0,HALF = 0.5D0, &
316
 
                                    ONE  = 1.0D0,THREE = 3.0D0, &
317
 
                                    verysmall = 1.0e-20
318
 
!     ..
319
 
!     .. Dummy Variables ..
320
 
      integer,intent(in)          :: r0,r1,z0,z1
321
 
!     ..
322
 
!     .. Dummy Arrays ..
323
 
      double precision,dimension(z1-z0+1),intent(in)           :: d_iso
324
 
      double precision,dimension(r0:r1-1,z0-1:z1-1),intent(in) :: efield
325
 
      double precision,dimension(r1-r0,z1-z0+4),intent(in)     :: data_array
326
 
      double precision,dimension(r1-r0,z1-z0+1),intent(out)    :: mat_z
327
 
!     ..
328
 
!     .. Local Variables ..
329
 
      integer          :: iz,length
330
 
!     ..
331
 
!     .. Local Arrays ..
332
 
      double precision,dimension(r1-r0,z1-z0+1) :: aux,psi_p,pij
333
 
      double precision,dimension(r1-r0,z1-z0+3) :: mat_diff
334
 
!-----------------------------------------------
335
 
      length = z1 - z0 + 1
336
 
      mat_diff(:,1:length+2) = data_array(:,2:length+3) - &
337
 
                               data_array(:,1:length+2)
338
 

	
339
 
      where (abs(mat_diff(:,2:length+1)) > verysmall)
340
 
         ! psi_p = (p - p_min) / (p_plus- p)
341
 
         where (efield>ZERO)
342
 
            ! p_min  =data_array(ir-k1,iz-k2)
343
 
            ! p      =data_array(ir,iz)
344
 
            ! p_plus =data_array(ir+k1,iz+k2)
345
 
   
346
 
            psi_p = mat_diff(:,1:length) / mat_diff(:,2:length+1)
347
 
         elsewhere ! efield=<ZERO
348
 
            ! p       =data_array(ir,iz)
349
 
            ! p_plus  =data_array(ir+  k1,iz+  k2)
350
 
            ! p_2plus =data_array(ir+2*k1,iz+2*k2)
351
 

	
352
 
            psi_p = mat_diff(:,3:length+2) / mat_diff(:,2:length+1) 
353
 
         end where
354
 
         ! psi_p = psi_MN (psi_p)
355
 
         pij   = psi_p
356
 
         where ((psi_p > 0.4) .and. (psi_p < 4))
357
 
            pij =  (ONE + HALF * psi_p) / THREE
358
 
         elsewhere (psi_p >= 4)
359
 
            pij = ONE
360
 
         else where (psi_p <= ZERO)
361
 
            pij = ZERO
362
 
         end where
363
 
      elsewhere ! abs(mat_diff(:,2:length+1)) < verysmall
364
 
         pij = ONE
365
 
      end where
366
 

	
367
 
      ! sigmasigma is (sigma_{i+1,j} - sigma_{i,j})*/
368
 
      ! sigmasigma = p - p_plus 
369
 
      aux = pij * mat_diff(:,2:length+1)
370
 
      ! aux = p + pij * sigmasigma
371
 
      where (efield>=0)
372
 
         aux = data_array(:,2:length+1) + aux
373
 
      elsewhere
374
 
         aux = data_array(:,3:length+2) - aux
375
 
      end where
376
 

	
377
 
      ! aux = efield * (p + pij * sigmasigma)
378
 
      aux = aux * efield
379
 
      do iz = 1,length
380
 
         ! mat_z = d_iso * sigmasigma
381
 
         mat_z(:,iz) = d_iso(iz) * mat_diff(:,iz+1)
382
 
      end do
383
 
      ! mat_z =  efield * (p + pij * sigmasigma) + d_iso * sigmasigma
384
 
      mat_z = aux - mat_z
385
 

	
386
 
   end subroutine mat_cdr_f_ad_z
387
 

	
388
 
   subroutine make_vecs_er (er_min,er,r0,r1,dr)
389
 
!     ..
390
 
      implicit none
391
 
!
392
 
!     .. Parameters ..
393
 
      double precision,parameter :: HALF = 0.5D0,ONE  = 1.0D0
394
 
!     ..
395
 
!     .. Dummy Variables ..
396
 
      integer,intent(in)                              :: r0,r1
397
 
      double precision,intent(in)                     :: dr
398
 
!     ..
399
 
!     .. Dummy Arrays ..
400
 
      double precision,dimension(r0:r1-1),intent(out) :: er_min
401
 
      double precision,dimension(r0+1:r1),intent(out) :: er
402
 
!     ..
403
 
!     .. Local Variables ..
404
 
      integer          :: ir
405
 
      double precision :: r_inv
406
 
!     ..
407
 
! .............................................................
408
 
      do ir = r0,r1-1
409
 
         r_inv = ONE / ((ir+ HALF) * dr)
410
 
         er_min(ir) = ir * r_inv
411
 
         er(ir+1)   = (ir+1) * r_inv
412
 
      end do
413
 

	
414
 
   end subroutine make_vecs_er
 
new file 100644
1
 
/** @file cdr_advect_diffu_wrap.c
2
 
*   @brief Wrapper function for the cdr_advect_diffu function. 
3
 
*
4
 
*   This function makes it possible to call the Fortran routine cdr_advect_vec
5
 
*   a c function. The c routine is named arcos_cdr_advect_vec.
6
 
*
7
 
*   @author Margreet Nool - 2009
8
 
*/
9
 

	
10
 
#include "stdlib.h"
11
 
#include "stdio.h"
12
 
#include "math.h"
13
 

	
14
 
int number_cdr=0;
15
 

	
16
 
/* cdr_advect: vectorized fortran90 routine; see f90/src/cdr_advect_vec.f90 */
17
 
void cdr_advect_vec_(double *mass,double *charge,double *dens_array, 
18
 
                 double *d_dens_array,double *er_array,double *ez_array,
19
 
		 double *diffusion_coeff,double *dr,double *dz,
20
 
		 int *sprite_module,int *r0,int *r1,int *z0,int *z1);
21
 

	
22
 
/* Calls hstcrt and checks for errors. If an error occurs, prints the
23
 
 corresponding message and exists. */
24
 
void 
25
 
arcos_cdr_advect_vec(double mass,double charge,double *dens_array, 
26
 
                 double *d_dens_array,double *er_array,int er_len,
27
 
		 double *ez_array,int ez_len,double diffusion_coeff,
28
 
                 double dr,double dz,int sprite_module,
29
 
                 int r0,int r1,int z0,int z1)
30
 
{
31
 
  if ( number_cdr % 1000 == 0 ) {
32
 

	
33
 
     fprintf(stdout, "wrap:# calls cdr_advec_vec       =%d\n",number_cdr);
34
 
     
35
 
  }
36
 

	
37
 
  cdr_advect_vec_(&mass,&charge,dens_array,d_dens_array,er_array,ez_array,
38
 
              &diffusion_coeff,&dr,&dz,&sprite_module,&r0,&r1,&z0,&z1);
39
 
  number_cdr += 1;
40
 

	
41
 
}
42
 

	
 
new file 100644
1
 
Use jannis versie van doxygen:
2
 

	
3
 
/ufs/teunisse/progs/doxygen-1.8.2/bin/doxygen
 
new file 100644
1
 
# Doxyfile 1.7.5
2
 

	
3
 
# This file describes the settings to be used by the documentation system
4
 
# doxygen (www.doxygen.org) for a project
5
 
#
6
 
# All text after a hash (#) is considered a comment and will be ignored
7
 
# The format is:
8
 
#       TAG = value [value, ...]
9
 
# For lists items can also be appended using:
10
 
#       TAG += value [value, ...]
11
 
# Values that contain spaces should be placed between quotes (" ")
12
 

	
13
 
#---------------------------------------------------------------------------
14
 
# Project related configuration options
15
 
#---------------------------------------------------------------------------
16
 

	
17
 
# This tag specifies the encoding used for all characters in the config file
18
 
# that follow. The default is UTF-8 which is also the encoding used for all
19
 
# text before the first occurrence of this tag. Doxygen uses libiconv (or the
20
 
# iconv built into libc) for the transcoding. See
21
 
# http://www.gnu.org/software/libiconv for the list of possible encodings.
22
 

	
23
 
DOXYFILE_ENCODING      = UTF-8
24
 

	
25
 
# The PROJECT_NAME tag is a single word (or a sequence of words surrounded
26
 
# by quotes) that should identify the project.
27
 

	
28
 
PROJECT_NAME           = "Streamer fluid modeling - An overview of ARCoS"
29
 

	
30
 
# The PRO4JECT_NUMBER tag can be used to enter a project or revision number.
31
 
# This could be handy for archiving the generated documentation or
32
 
# if some version control system is used.
33
 

	
34
 
PROJECT_NUMBER         = 1.0
35
 

	
36
 
# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
37
 
# base path where the generated documentation will be put.
38
 
# If a relative path is entered, it will be relative to the location
39
 
# where doxygen was started. If left blank the current directory will be used.
40
 

	
41
 
OUTPUT_DIRECTORY       = documentation
42
 

	
43
 
# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
44
 
# 4096 sub-directories (in 2 levels) under the output directory of each output
45
 
# format and will distribute the generated files over these directories.
46
 
# Enabling this option can be useful when feeding doxygen a huge amount of
47
 
# source files, where putting all generated files in the same directory would
48
 
# otherwise cause performance problems for the file system.
49
 

	
50
 
CREATE_SUBDIRS         = NO
51
 

	
52
 
# The OUTPUT_LANGUAGE tag is used to specify the language in which all
53
 
# documentation generated by doxygen is written. Doxygen will use this
54
 
# information to generate all constant output in the proper language.
55
 
# The default language is English, other supported languages are:
56
 
# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
57
 
# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
58
 
# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
59
 
# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
60
 
# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak,
61
 
# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
62
 

	
63
 
OUTPUT_LANGUAGE        = English
64
 

	
65
 
# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
66
 
# include brief member descriptions after the members that are listed in
67
 
# the file and class documentation (similar to JavaDoc).
68
 
# Set to NO to disable this.
69
 

	
70
 
BRIEF_MEMBER_DESC      = YES
71
 

	
72
 
# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
73
 
# the brief description of a member or function before the detailed description.
74
 
# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
75
 
# brief descriptions will be completely suppressed.
76
 

	
77
 
REPEAT_BRIEF           = YES
78
 

	
79
 
# This tag implements a quasi-intelligent brief description abbreviator
80
 
# that is used to form the text in various listings. Each string
81
 
# in this list, if found as the leading text of the brief description, will be
82
 
# stripped from the text and the result after processing the whole list, is
83
 
# used as the annotated text. Otherwise, the brief description is used as-is.
84
 
# If left blank, the following values are used ("$name" is automatically
85
 
# replaced with the name of the entity): "The $name class" "The $name widget"
86
 
# "The $name file" "is" "provides" "specifies" "contains"
87
 
# "represents" "a" "an" "the"
88
 

	
89
 
ABBREVIATE_BRIEF       =
90
 

	
91
 
# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
92
 
# Doxygen will generate a detailed section even if there is only a brief
93
 
# description.
94
 

	
95
 
ALWAYS_DETAILED_SEC    = NO
96
 

	
97
 
# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
98
 
# inherited members of a class in the documentation of that class as if those
99
 
# members were ordinary class members. Constructors, destructors and assignment
100
 
# operators of the base classes will not be shown.
101
 

	
102
 
INLINE_INHERITED_MEMB  = NO
103
 

	
104
 
# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
105
 
# path before files name in the file list and in the header files. If set
106
 
# to NO the shortest path that makes the file name unique will be used.
107
 

	
108
 
FULL_PATH_NAMES        = NO
109
 

	
110
 
# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
111
 
# can be used to strip a user-defined part of the path. Stripping is
112
 
# only done if one of the specified strings matches the left-hand part of
113
 
# the path. The tag can be used to show relative paths in the file list.
114
 
# If left blank the directory from which doxygen is run is used as the
115
 
# path to strip.
116
 

	
117
 
STRIP_FROM_PATH        =
118
 

	
119
 
# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
120
 
# the path mentioned in the documentation of a class, which tells
121
 
# the reader which header file to include in order to use a class.
122
 
# If left blank only the name of the header file containing the class
123
 
# definition is used. Otherwise one should specify the include paths that
124
 
# are normally passed to the compiler using the -I flag.
125
 

	
126
 
STRIP_FROM_INC_PATH    =
127
 

	
128
 
# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
129
 
# (but less readable) file names. This can be useful is your file systems
130
 
# doesn't support long names like on DOS, Mac, or CD-ROM.
131
 

	
132
 
SHORT_NAMES            = NO
133
 

	
134
 
# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
135
 
# will interpret the first line (until the first dot) of a JavaDoc-style
136
 
# comment as the brief description. If set to NO, the JavaDoc
137
 
# comments will behave just like regular Qt-style comments
138
 
# (thus requiring an explicit @brief command for a brief description.)
139
 

	
140
 
JAVADOC_AUTOBRIEF      = NO
141
 

	
142
 
# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
143
 
# interpret the first line (until the first dot) of a Qt-style
144
 
# comment as the brief description. If set to NO, the comments
145
 
# will behave just like regular Qt-style comments (thus requiring
146
 
# an explicit \brief command for a brief description.)
147
 

	
148
 
QT_AUTOBRIEF           = NO
149
 

	
150
 
# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
151
 
# treat a multi-line C++ special comment block (i.e. a block of //! or ///
152
 
# comments) as a brief description. This used to be the default behaviour.
153
 
# The new default is to treat a multi-line C++ comment block as a detailed
154
 
# description. Set this tag to YES if you prefer the old behaviour instead.
155
 

	
156
 
MULTILINE_CPP_IS_BRIEF = NO
157
 

	
158
 
# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
159
 
# member inherits the documentation from any documented member that it
160
 
# re-implements.
161
 

	
162
 
INHERIT_DOCS           = YES
163
 

	
164
 
# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
165
 
# a new page for each member. If set to NO, the documentation of a member will
166
 
# be part of the file/class/namespace that contains it.
167
 

	
168
 
SEPARATE_MEMBER_PAGES  = NO
169
 

	
170
 
# The TAB_SIZE tag can be used to set the number of spaces in a tab.
171
 
# Doxygen uses this value to replace tabs by spaces in code fragments.
172
 

	
173
 
TAB_SIZE               = 3
174
 

	
175
 
# This tag can be used to specify a number of aliases that acts
176
 
# as commands in the documentation. An alias has the form "name=value".
177
 
# For example adding "sideeffect=\par Side Effects:\n" will allow you to
178
 
# put the command \sideeffect (or @sideeffect) in the documentation, which
179
 
# will result in a user-defined paragraph with heading "Side Effects:".
180
 
# You can put \n's in the value part of an alias to insert newlines.
181
 

	
182
 
ALIASES                =
183
 

	
184
 
# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
185
 
# sources only. Doxygen will then generate output that is more tailored for C.
186
 
# For instance, some of the names that are used will be different. The list
187
 
# of all members will be omitted, etc.
188
 

	
189
 
OPTIMIZE_OUTPUT_FOR_C  = NO
190
 

	
191
 
# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
192
 
# sources only. Doxygen will then generate output that is more tailored for
193
 
# Java. For instance, namespaces will be presented as packages, qualified
194
 
# scopes will look different, etc.
195
 

	
196
 
OPTIMIZE_OUTPUT_JAVA   = NO
197
 

	
198
 
# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
199
 
# sources only. Doxygen will then generate output that is more tailored for
200
 
# Fortran.
201
 

	
202
 
OPTIMIZE_FOR_FORTRAN   = YES
203
 

	
204
 
# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
205
 
# sources. Doxygen will then generate output that is tailored for
206
 
# VHDL.
207
 

	
208
 
OPTIMIZE_OUTPUT_VHDL   = NO
209
 

	
210
 
# Doxygen selects the parser to use depending on the extension of the files it
211
 
# parses. With this tag you can assign which parser to use for a given extension.
212
 
# Doxygen has a built-in mapping, but you can override or extend it using this
213
 
# tag. The format is ext=language, where ext is a file extension, and language
214
 
# is one of the parsers supported by doxygen: IDL, Java, Javascript, CSharp, C,
215
 
# C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, C++. For instance to make
216
 
# doxygen treat .inc files as Fortran files (default is PHP), and .f files as C
217
 
# (default is Fortran), use: inc=Fortran f=C. Note that for custom extensions
218
 
# you also need to set FILE_PATTERNS otherwise the files are not read by doxygen.
219
 

	
220
 
EXTENSION_MAPPING      = *.F
221
 

	
222
 
# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
223
 
# to include (a tag file for) the STL sources as input, then you should
224
 
# set this tag to YES in order to let doxygen match functions declarations and
225
 
# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
226
 
# func(std::string) {}). This also make the inheritance and collaboration
227
 
# diagrams that involve STL classes more complete and accurate.
228
 

	
229
 
#BUILTIN_STL_SUPPORT    = NO
230
 
BUILTIN_STL_SUPPORT    = YES
231
 

	
232
 
# If you use Microsoft's C++/CLI language, you should set this option to YES to
233
 
# enable parsing support.
234
 

	
235
 
CPP_CLI_SUPPORT        = NO
236
 

	
237
 
# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
238
 
# Doxygen will parse them like normal C++ but will assume all classes use public
239
 
# instead of private inheritance when no explicit protection keyword is present.
240
 

	
241
 
SIP_SUPPORT            = NO
242
 

	
243
 
# For Microsoft's IDL there are propget and propput attributes to indicate getter
244
 
# and setter methods for a property. Setting this option to YES (the default)
245
 
# will make doxygen to replace the get and set methods by a property in the
246
 
# documentation. This will only work if the methods are indeed getting or
247
 
# setting a simple type. If this is not the case, or you want to show the
248
 
# methods anyway, you should set this option to NO.
249
 

	
250
 
IDL_PROPERTY_SUPPORT   = YES
251
 

	
252
 
# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
253
 
# tag is set to YES, then doxygen will reuse the documentation of the first
254
 
# member in the group (if any) for the other members of the group. By default
255
 
# all members of a group must be documented explicitly.
256
 

	
257
 
DISTRIBUTE_GROUP_DOC   = NO
258
 

	
259
 
# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
260
 
# the same type (for instance a group of public functions) to be put as a
261
 
# subgroup of that type (e.g. under the Public Functions section). Set it to
262
 
# NO to prevent subgrouping. Alternatively, this can be done per class using
263
 
# the \nosubgrouping command.
264
 

	
265
 
SUBGROUPING            = YES
266
 

	
267
 
# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
268
 
# is documented as struct, union, or enum with the name of the typedef. So
269
 
# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
270
 
# with name TypeT. When disabled the typedef will appear as a member of a file,
271
 
# namespace, or class. And the struct will be named TypeS. This can typically
272
 
# be useful for C code in case the coding convention dictates that all compound
273
 
# types are typedef'ed and only the typedef is referenced, never the tag name.
274
 

	
275
 
TYPEDEF_HIDES_STRUCT   = NO
276
 

	
277
 
# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
278
 
# determine which symbols to keep in memory and which to flush to disk.
279
 
# When the cache is full, less often used symbols will be written to disk.
280
 
# For small to medium size projects (<1000 input files) the default value is
281
 
# probably good enough. For larger projects a too small cache size can cause
282
 
# doxygen to be busy swapping symbols to and from disk most of the time
283
 
# causing a significant performance penality.
284
 
# If the system has enough physical memory increasing the cache will improve the
285
 
# performance by keeping more symbols in memory. Note that the value works on
286
 
# a logarithmic scale so increasing the size by one will rougly double the
287
 
# memory usage. The cache size is given by this formula:
288
 
# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
289
 
# corresponding to a cache size of 2^16 = 65536 symbols
290
 

	
291
 
SYMBOL_CACHE_SIZE      = 0
292
 

	
293
 
#---------------------------------------------------------------------------
294
 
# Build related configuration options
295
 
#---------------------------------------------------------------------------
296
 

	
297
 
# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
298
 
# documentation are documented, even if no documentation was available.
299
 
# Private class members and static file members will be hidden unless
300
 
# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
301
 

	
302
 
EXTRACT_ALL            = YES
303
 

	
304
 
# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
305
 
# will be included in the documentation.
306
 

	
307
 
EXTRACT_PRIVATE        = YES
308
 

	
309
 
# If the EXTRACT_STATIC tag is set to YES all static members of a file
310
 
# will be included in the documentation.
311
 

	
312
 
EXTRACT_STATIC         = YES
313
 

	
314
 
# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
315
 
# defined locally in source files will be included in the documentation.
316
 
# If set to NO only classes defined in header files are included.
317
 

	
318
 
EXTRACT_LOCAL_CLASSES  = YES
319
 

	
320
 
# This flag is only useful for Objective-C code. When set to YES local
321
 
# methods, which are defined in the implementation section but not in
322
 
# the interface are included in the documentation.
323
 
# If set to NO (the default) only methods in the interface are included.
324
 

	
325
 
EXTRACT_LOCAL_METHODS  = YES
326
 

	
327
 
# If this flag is set to YES, the members of anonymous namespaces will be
328
 
# extracted and appear in the documentation as a namespace called
329
 
# 'anonymous_namespace{file}', where file will be replaced with the base
330
 
# name of the file that contains the anonymous namespace. By default
331
 
# anonymous namespace are hidden.
332
 

	
333
 
EXTRACT_ANON_NSPACES   = NO
334
 

	
335
 
# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
336
 
# undocumented members of documented classes, files or namespaces.
337
 
# If set to NO (the default) these members will be included in the
338
 
# various overviews, but no documentation section is generated.
339
 
# This option has no effect if EXTRACT_ALL is enabled.
340
 

	
341
 
HIDE_UNDOC_MEMBERS     = NO
342
 

	
343
 
# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
344
 
# undocumented classes that are normally visible in the class hierarchy.
345
 
# If set to NO (the default) these classes will be included in the various
346
 
# overviews. This option has no effect if EXTRACT_ALL is enabled.
347
 

	
348
 
HIDE_UNDOC_CLASSES     = NO
349
 

	
350
 
# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
351
 
# friend (class|struct|union) declarations.
352
 
# If set to NO (the default) these declarations will be included in the
353
 
# documentation.
354
 

	
355
 
HIDE_FRIEND_COMPOUNDS  = NO
356
 

	
357
 
# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
358
 
# documentation blocks found inside the body of a function.
359
 
# If set to NO (the default) these blocks will be appended to the
360
 
# function's detailed documentation block.
361
 

	
362
 
HIDE_IN_BODY_DOCS      = NO
363
 

	
364
 
# The INTERNAL_DOCS tag determines if documentation
365
 
# that is typed after a \internal command is included. If the tag is set
366
 
# to NO (the default) then the documentation will be excluded.
367
 
# Set it to YES to include the internal documentation.
368
 

	
369
 
INTERNAL_DOCS          = NO
370
 

	
371
 
# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
372
 
# file names in lower-case letters. If set to YES upper-case letters are also
373
 
# allowed. This is useful if you have classes or files whose names only differ
374
 
# in case and if your file system supports case sensitive file names. Windows
375
 
# and Mac users are advised to set this option to NO.
376
 

	
377
 
CASE_SENSE_NAMES       =  YES
378
 

	
379
 
# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
380
 
# will show members with their full class and namespace scopes in the
381
 
# documentation. If set to YES the scope will be hidden.
382
 

	
383
 
HIDE_SCOPE_NAMES       = NO
384
 

	
385
 
# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
386
 
# will put a list of the files that are included by a file in the documentation
387
 
# of that file.
388
 

	
389
 
SHOW_INCLUDE_FILES     = YES
390
 

	
391
 
# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
392
 
# will list include files with double quotes in the documentation
393
 
# rather than with sharp brackets.
394
 

	
395
 
FORCE_LOCAL_INCLUDES   = NO
396
 

	
397
 
# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
398
 
# is inserted in the documentation for inline members.
399
 

	
400
 
INLINE_INFO            = YES
401
 

	
402
 
# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
403
 
# will sort the (detailed) documentation of file and class members
404
 
# alphabetically by member name. If set to NO the members will appear in
405
 
# declaration order.
406
 

	
407
 
#SORT_MEMBER_DOCS       = YES
408
 
SORT_MEMBER_DOCS       = NO
409
 

	
410
 
# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
411
 
# brief documentation of file, namespace and class members alphabetically
412
 
# by member name. If set to NO (the default) the members will appear in
413
 
# declaration order.
414
 

	
415
 
SORT_BRIEF_DOCS        = NO
416
 

	
417
 
# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
418
 
# will sort the (brief and detailed) documentation of class members so that
419
 
# constructors and destructors are listed first. If set to NO (the default)
420
 
# the constructors will appear in the respective orders defined by
421
 
# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
422
 
# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
423
 
# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
424
 

	
425
 
SORT_MEMBERS_CTORS_1ST = NO
426
 

	
427
 
# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
428
 
# hierarchy of group names into alphabetical order. If set to NO (the default)
429
 
# the group names will appear in their defined order.
430
 

	
431
 
SORT_GROUP_NAMES       = NO
432
 

	
433
 
# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
434
 
# sorted by fully-qualified names, including namespaces. If set to
435
 
# NO (the default), the class list will be sorted only by class name,
436
 
# not including the namespace part.
437
 
# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
438
 
# Note: This option applies only to the class list, not to the
439
 
# alphabetical list.
440
 

	
441
 
SORT_BY_SCOPE_NAME     = NO
442
 

	
443
 
# The GENERATE_TODOLIST tag can be used to enable (YES) or
444
 
# disable (NO) the todo list. This list is created by putting \todo
445
 
# commands in the documentation.
446
 

	
447
 
GENERATE_TODOLIST      = YES
448
 

	
449
 
# The GENERATE_TESTLIST tag can be used to enable (YES) or
450
 
# disable (NO) the test list. This list is created by putting \test
451
 
# commands in the documentation.
452
 

	
453
 
GENERATE_TESTLIST      = YES
454
 

	
455
 
# The GENERATE_BUGLIST tag can be used to enable (YES) or
456
 
# disable (NO) the bug list. This list is created by putting \bug
457
 
# commands in the documentation.
458
 

	
459
 
GENERATE_BUGLIST       = YES
460
 

	
461
 
# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
462
 
# disable (NO) the deprecated list. This list is created by putting
463
 
# \deprecated commands in the documentation.
464
 

	
465
 
GENERATE_DEPRECATEDLIST= YES
466
 

	
467
 
# The ENABLED_SECTIONS tag can be used to enable conditional
468
 
# documentation sections, marked by \if sectionname ... \endif.
469
 

	
470
 
ENABLED_SECTIONS       =
471
 

	
472
 
# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
473
 
# the initial value of a variable or define consists of for it to appear in
474
 
# the documentation. If the initializer consists of more lines than specified
475
 
# here it will be hidden. Use a value of 0 to hide initializers completely.
476
 
# The appearance of the initializer of individual variables and defines in the
477
 
# documentation can be controlled using \showinitializer or \hideinitializer
478
 
# command in the documentation regardless of this setting.
479
 

	
480
 
MAX_INITIALIZER_LINES  = 30
481
 

	
482
 
# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
483
 
# at the bottom of the documentation of classes and structs. If set to YES the
484
 
# list will mention the files that were used to generate the documentation.
485
 

	
486
 
SHOW_USED_FILES        = YES
487
 

	
488
 
# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
489
 
# This will remove the Files entry from the Quick Index and from the
490
 
# Folder Tree View (if specified). The default is YES.
491
 

	
492
 
SHOW_FILES             = YES
493
 

	
494
 
# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
495
 
# Namespaces page.
496
 
# This will remove the Namespaces entry from the Quick Index
497
 
# and from the Folder Tree View (if specified). The default is YES.
498
 

	
499
 
SHOW_NAMESPACES        = YES
500
 

	
501
 
# The FILE_VERSION_FILTER tag can be used to specify a program or script that
502
 
# doxygen should invoke to get the current version for each file (typically from
503
 
# the version control system). Doxygen will invoke the program by executing (via
504
 
# popen()) the command <command> <input-file>, where <command> is the value of
505
 
# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
506
 
# provided by doxygen. Whatever the program writes to standard output
507
 
# is used as the file version. See the manual for examples.
508
 

	
509
 
FILE_VERSION_FILTER    =
510
 

	
511
 
# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
512
 
# by doxygen. The layout file controls the global structure of the generated
513
 
# output files in an output format independent way. The create the layout file
514
 
# that represents doxygen's defaults, run doxygen with the -l option.
515
 
# You can optionally specify a file name after the option, if omitted
516
 
# DoxygenLayout.xml will be used as the name of the layout file.
517
 

	
518
 
LAYOUT_FILE            =
519
 

	
520
 
#---------------------------------------------------------------------------
521
 
# configuration options related to warning and progress messages
522
 
#---------------------------------------------------------------------------
523
 

	
524
 
# The QUIET tag can be used to turn on/off the messages that are generated
525
 
# by doxygen. Possible values are YES and NO. If left blank NO is used.
526
 

	
527
 
QUIET                  = NO
528
 

	
529
 
# The WARNINGS tag can be used to turn on/off the warning messages that are
530
 
# generated by doxygen. Possible values are YES and NO. If left blank
531
 
# NO is used.
532
 

	
533
 
WARNINGS               = YES
534
 

	
535
 
# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
536
 
# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
537
 
# automatically be disabled.
538
 

	
539
 
WARN_IF_UNDOCUMENTED   = YES
540
 

	
541
 
# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
542
 
# potential errors in the documentation, such as not documenting some
543
 
# parameters in a documented function, or documenting parameters that
544
 
# don't exist or using markup commands wrongly.
545
 

	
546
 
WARN_IF_DOC_ERROR      = YES
547
 

	
548
 
# This WARN_NO_PARAMDOC option can be abled to get warnings for
549
 
# functions that are documented, but have no documentation for their parameters
550
 
# or return value. If set to NO (the default) doxygen will only warn about
551
 
# wrong or incomplete parameter documentation, but not about the absence of
552
 
# documentation.
553
 

	
554
 
WARN_NO_PARAMDOC       = NO
555
 

	
556
 
# The WARN_FORMAT tag determines the format of the warning messages that
557
 
# doxygen can produce. The string should contain the $file, $line, and $text
558
 
# tags, which will be replaced by the file and line number from which the
559
 
# warning originated and the warning text. Optionally the format may contain
560
 
# $version, which will be replaced by the version of the file (if it could
561
 
# be obtained via FILE_VERSION_FILTER)
562
 

	
563
 
WARN_FORMAT            = "$file:$line: $text"
564
 

	
565
 
# The WARN_LOGFILE tag can be used to specify a file to which warning
566
 
# and error messages should be written. If left blank the output is written
567
 
# to stderr.
568
 

	
569
 
WARN_LOGFILE           =
570
 

	
571
 
#---------------------------------------------------------------------------
572
 
# configuration options related to the input files
573
 
#---------------------------------------------------------------------------
574
 

	
575
 
# The INPUT tag can be used to specify the files and/or directories that contain
576
 
# documented source files. You may enter file names like "myfile.cpp" or
577
 
# directories like "/usr/src/myproject". Separate the files or directories
578
 
# with spaces.
579
 

	
580
 
INPUT                  =  ../src ../include ../input markdown ../arcos_f90/src
581
 

	
582
 
# This tag can be used to specify the character encoding of the source files
583
 
# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
584
 
# also the default input encoding. Doxygen uses libiconv (or the iconv built
585
 
# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
586
 
# the list of possible encodings.
587
 

	
588
 
INPUT_ENCODING         = UTF-8
589
 

	
590
 
# If the value of the INPUT tag contains directories, you can use the
591
 
# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
592
 
# and *.h) to filter out the source-files in the directories. If left
593
 
# blank the following patterns are tested:
594
 
# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx
595
 
# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90
596
 

	
597
 
FILE_PATTERNS          = *.c *.h MA*.md *.eps *.bib *.cfg *f90
598
 
#FILE_PATTERNS          = MA*.md *.eps *.bib
599
 

	
600
 
# The RECURSIVE tag can be used to turn specify whether or not subdirectories
601
 
# should be searched for input files as well. Possible values are YES and NO.
602
 
# If left blank NO is used.
603
 

	
604
 
RECURSIVE              = NO
605
 

	
606
 
# The EXCLUDE tag can be used to specify files and/or directories that should
607
 
# excluded from the INPUT source files. This way you can easily exclude a
608
 
# subdirectory from a directory tree whose root is specified with the INPUT tag.
609
 

	
610
 
EXCLUDE                =
611
 

	
612
 
# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
613
 
# directories that are symbolic links (a Unix filesystem feature) are excluded
614
 
# from the input.
615
 

	
616
 
EXCLUDE_SYMLINKS       = NO
617
 

	
618
 
# If the value of the INPUT tag contains directories, you can use the
619
 
# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
620
 
# certain files from those directories. Note that the wildcards are matched
621
 
# against the file with absolute path, so to exclude all test directories
622
 
# for example use the pattern */test/*
623
 

	
624
 
EXCLUDE_PATTERNS       = *.f
625
 

	
626
 
# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
627
 
# (namespaces, classes, functions, etc.) that should be excluded from the
628
 
# output. The symbol name can be a fully qualified name, a word, or if the
629
 
# wildcard * is used, a substring. Examples: ANamespace, AClass,
630
 
# AClass::ANamespace, ANamespace::*Test
631
 

	
632
 
EXCLUDE_SYMBOLS        =
633
 

	
634
 
# The EXAMPLE_PATH tag can be used to specify one or more files or
635
 
# directories that contain example code fragments that are included (see
636
 
# the \include command).
637
 

	
638
 
EXAMPLE_PATH           =
639
 

	
640
 
# If the value of the EXAMPLE_PATH tag contains directories, you can use the
641
 
# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
642
 
# and *.h) to filter out the source-files in the directories. If left
643
 
# blank all files are included.
644
 

	
645
 
EXAMPLE_PATTERNS       =
646
 

	
647
 
# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
648
 
# searched for input files to be used with the \include or \dontinclude
649
 
# commands irrespective of the value of the RECURSIVE tag.
650
 
# Possible values are YES and NO. If left blank NO is used.
651
 

	
652
 
EXAMPLE_RECURSIVE      = NO
653
 

	
654
 
# The IMAGE_PATH tag can be used to specify one or more files or
655
 
# directories that contain image that are included in the documentation (see
656
 
# the \image command).
657
 

	
658
 
IMAGE_PATH             = figures
659
 

	
660
 
# The INPUT_FILTER tag can be used to specify a program that doxygen should
661
 
# invoke to filter for each input file. Doxygen will invoke the filter program
662
 
# by executing (via popen()) the command <filter> <input-file>, where <filter>
663
 
# is the value of the INPUT_FILTER tag, and <input-file> is the name of an
664
 
# input file. Doxygen will then use the output that the filter program writes
665
 
# to standard output.
666
 
# If FILTER_PATTERNS is specified, this tag will be
667
 
# ignored.
668
 

	
669
 
INPUT_FILTER           =
670
 

	
671
 
# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
672
 
# basis.
673
 
# Doxygen will compare the file name with each pattern and apply the
674
 
# filter if there is a match.
675
 
# The filters are a list of the form:
676
 
# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
677
 
# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER
678
 
# is applied to all files.
679
 

	
680
 
FILTER_PATTERNS        =
681
 

	
682
 
# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
683
 
# INPUT_FILTER) will be used to filter the input files when producing source
684
 
# files to browse (i.e. when SOURCE_BROWSER is set to YES).
685
 

	
686
 
FILTER_SOURCE_FILES    = NO
687
 

	
688
 
#---------------------------------------------------------------------------
689
 
# configuration options related to source browsing
690
 
#---------------------------------------------------------------------------
691
 

	
692
 
# If the SOURCE_BROWSER tag is set to YES then a list of source files will
693
 
# be generated. Documented entities will be cross-referenced with these sources.
694
 
# Note: To get rid of all source code in the generated output, make sure also
695
 
# VERBATIM_HEADERS is set to NO.
696
 

	
697
 
#SOURCE_BROWSER         = NO
698
 
SOURCE_BROWSER         = YES
699
 

	
700
 
# Setting the INLINE_SOURCES tag to YES will include the body
701
 
# of functions and classes directly in the documentation.
702
 

	
703
 
INLINE_SOURCES         = NO
704
 

	
705
 
# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
706
 
# doxygen to hide any special comment blocks from generated source code
707
 
# fragments. Normal C and C++ comments will always remain visible.
708
 

	
709
 
STRIP_CODE_COMMENTS    = YES
710
 

	
711
 
# If the REFERENCED_BY_RELATION tag is set to YES
712
 
# then for each documented function all documented
713
 
# functions referencing it will be listed.
714
 

	
715
 
REFERENCED_BY_RELATION = NO
716
 

	
717
 
# If the REFERENCES_RELATION tag is set to YES
718
 
# then for each documented function all documented entities
719
 
# called/used by that function will be listed.
720
 

	
721
 
REFERENCES_RELATION    = NO
722
 

	
723
 
# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
724
 
# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
725
 
# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
726
 
# link to the source code.
727
 
# Otherwise they will link to the documentation.
728
 

	
729
 
REFERENCES_LINK_SOURCE = YES
730
 

	
731
 
# If the USE_HTAGS tag is set to YES then the references to source code
732
 
# will point to the HTML generated by the htags(1) tool instead of doxygen
733
 
# built-in source browser. The htags tool is part of GNU's global source
734
 
# tagging system (see http://www.gnu.org/software/global/global.html). You
735
 
# will need version 4.8.6 or higher.
736
 

	
737
 
USE_HTAGS              = NO
738
 

	
739
 
# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
740
 
# will generate a verbatim copy of the header file for each class for
741
 
# which an include is specified. Set to NO to disable this.
742
 

	
743
 
VERBATIM_HEADERS       = YES
744
 

	
745
 
#---------------------------------------------------------------------------
746
 
# configuration options related to the alphabetical class index
747
 
#---------------------------------------------------------------------------
748
 

	
749
 
# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
750
 
# of all compounds will be generated. Enable this if the project
751
 
# contains a lot of classes, structs, unions or interfaces.
752
 

	
753
 
ALPHABETICAL_INDEX     = NO
754
 

	
755
 
# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
756
 
# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
757
 
# in which this list will be split (can be a number in the range [1..20])
758
 

	
759
 
COLS_IN_ALPHA_INDEX    = 5
760
 

	
761
 
# In case all classes in a project start with a common prefix, all
762
 
# classes will be put under the same header in the alphabetical index.
763
 
# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
764
 
# should be ignored while generating the index headers.
765
 

	
766
 
IGNORE_PREFIX          =
767
 

	
768
 
#---------------------------------------------------------------------------
769
 
# configuration options related to the HTML output
770
 
#---------------------------------------------------------------------------
771
 

	
772
 
# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
773
 
# generate HTML output.
774
 

	
775
 
GENERATE_HTML          = YES
776
 

	
777
 
# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
778
 
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
779
 
# put in front of it. If left blank `html' will be used as the default path.
780
 

	
781
 
HTML_OUTPUT            = html
782
 

	
783
 
# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
784
 
# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
785
 
# doxygen will generate files with .html extension.
786
 

	
787
 
HTML_FILE_EXTENSION    = .html
788
 

	
789
 
# The HTML_HEADER tag can be used to specify a personal HTML header for
790
 
# each generated HTML page. If it is left blank doxygen will generate a
791
 
# standard header.
792
 

	
793
 
HTML_HEADER            =
794
 

	
795
 
# The HTML_FOOTER tag can be used to specify a personal HTML footer for
796
 
# each generated HTML page. If it is left blank doxygen will generate a
797
 
# standard footer.
798
 

	
799
 
HTML_FOOTER            =
800
 

	
801
 
# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
802
 
# style sheet that is used by each HTML page. It can be used to
803
 
# fine-tune the look of the HTML output. If the tag is left blank doxygen
804
 
# will generate a default style sheet. Note that doxygen will try to copy
805
 
# the style sheet file to the HTML output directory, so don't put your own
806
 
# stylesheet in the HTML output directory as well, or it will be erased!
807
 

	
808
 
HTML_STYLESHEET        =
809
 

	
810
 
# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
811
 
# Doxygen will adjust the colors in the stylesheet and background images
812
 
# according to this color. Hue is specified as an angle on a colorwheel,
813
 
# see http://en.wikipedia.org/wiki/Hue for more information.
814
 
# For instance the value 0 represents red, 60 is yellow, 120 is green,
815
 
# 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
816
 
# The allowed range is 0 to 359.
817
 

	
818
 
HTML_COLORSTYLE_HUE    = 220
819
 

	
820
 
# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
821
 
# the colors in the HTML output. For a value of 0 the output will use
822
 
# grayscales only. A value of 255 will produce the most vivid colors.
823
 

	
824
 
HTML_COLORSTYLE_SAT    = 100
825
 

	
826
 
# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
827
 
# the luminance component of the colors in the HTML output. Values below
828
 
# 100 gradually make the output lighter, whereas values above 100 make
829
 
# the output darker. The value divided by 100 is the actual gamma applied,
830
 
# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
831
 
# and 100 does not change the gamma.
832
 

	
833
 
HTML_COLORSTYLE_GAMMA  = 80
834
 

	
835
 
# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
836
 
# page will contain the date and time when the page was generated. Setting
837
 
# this to NO can help when comparing the output of multiple runs.
838
 

	
839
 
HTML_TIMESTAMP         = YES
840
 

	
841
 
# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
842
 
# documentation will contain sections that can be hidden and shown after the
843
 
# page has loaded. For this to work a browser that supports
844
 
# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox
845
 
# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
846
 

	
847
 
HTML_DYNAMIC_SECTIONS  = NO
848
 

	
849
 
# If the GENERATE_DOCSET tag is set to YES, additional index files
850
 
# will be generated that can be used as input for Apple's Xcode 3
851
 
# integrated development environment, introduced with OSX 10.5 (Leopard).
852
 
# To create a documentation set, doxygen will generate a Makefile in the
853
 
# HTML output directory. Running make will produce the docset in that
854
 
# directory and running "make install" will install the docset in
855
 
# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
856
 
# it at startup.
857
 
# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
858
 
# for more information.
859
 

	
860
 
GENERATE_DOCSET        = NO
861
 

	
862
 
# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
863
 
# feed. A documentation feed provides an umbrella under which multiple
864
 
# documentation sets from a single provider (such as a company or product suite)
865
 
# can be grouped.
866
 

	
867
 
DOCSET_FEEDNAME        = "Doxygen generated docs 1.7.4"
868
 

	
869
 
# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
870
 
# should uniquely identify the documentation set bundle. This should be a
871
 
# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
872
 
# will append .docset to the name.
873
 

	
874
 
DOCSET_BUNDLE_ID       = org.doxygen.Project
875
 

	
876
 
# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify
877
 
# the documentation publisher. This should be a reverse domain-name style
878
 
# string, e.g. com.mycompany.MyDocSet.documentation.
879
 

	
880
 
DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
881
 

	
882
 
# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
883
 

	
884
 
DOCSET_PUBLISHER_NAME  = Publisher
885
 

	
886
 
# If the GENERATE_HTMLHELP tag is set to YES, additional index files
887
 
# will be generated that can be used as input for tools like the
888
 
# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
889
 
# of the generated HTML documentation.
890
 

	
891
 
GENERATE_HTMLHELP      = NO
892
 

	
893
 
# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
894
 
# be used to specify the file name of the resulting .chm file. You
895
 
# can add a path in front of the file if the result should not be
896
 
# written to the html output directory.
897
 

	
898
 
CHM_FILE               =
899
 

	
900
 
# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
901
 
# be used to specify the location (absolute path including file name) of
902
 
# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
903
 
# the HTML help compiler on the generated index.hhp.
904
 

	
905
 
HHC_LOCATION           =
906
 

	
907
 
# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
908
 
# controls if a separate .chi index file is generated (YES) or that
909
 
# it should be included in the master .chm file (NO).
910
 

	
911
 
GENERATE_CHI           = NO
912
 

	
913
 
# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
914
 
# is used to encode HtmlHelp index (hhk), content (hhc) and project file
915
 
# content.
916
 

	
917
 
CHM_INDEX_ENCODING     =
918
 

	
919
 
# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
920
 
# controls whether a binary table of contents is generated (YES) or a
921
 
# normal table of contents (NO) in the .chm file.
922
 

	
923
 
BINARY_TOC             = NO
924
 

	
925
 
# The TOC_EXPAND flag can be set to YES to add extra items for group members
926
 
# to the contents of the HTML help documentation and to the tree view.
927
 

	
928
 
TOC_EXPAND             = NO
929
 

	
930
 
# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
931
 
# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
932
 
# that can be used as input for Qt's qhelpgenerator to generate a
933
 
# Qt Compressed Help (.qch) of the generated HTML documentation.
934
 

	
935
 
GENERATE_QHP           = NO
936
 

	
937
 
# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
938
 
# be used to specify the file name of the resulting .qch file.
939
 
# The path specified is relative to the HTML output folder.
940
 

	
941
 
QCH_FILE               =
942
 

	
943
 
# The QHP_NAMESPACE tag specifies the namespace to use when generating
944
 
# Qt Help Project output. For more information please see
945
 
# http://doc.trolltech.com/qthelpproject.html#namespace
946
 

	
947
 
QHP_NAMESPACE          = org.doxygen.Project
948
 

	
949
 
# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
950
 
# Qt Help Project output. For more information please see
951
 
# http://doc.trolltech.com/qthelpproject.html#virtual-folders
952
 

	
953
 
QHP_VIRTUAL_FOLDER     = doc
954
 

	
955
 
# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
956
 
# add. For more information please see
957
 
# http://doc.trolltech.com/qthelpproject.html#custom-filters
958
 

	
959
 
QHP_CUST_FILTER_NAME   =
960
 

	
961
 
# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
962
 
# custom filter to add. For more information please see
963
 
# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">
964
 
# Qt Help Project / Custom Filters</a>.
965
 

	
966
 
QHP_CUST_FILTER_ATTRS  =
967
 

	
968
 
# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
969
 
# project's
970
 
# filter section matches.
971
 
# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">
972
 
# Qt Help Project / Filter Attributes</a>.
973
 

	
974
 
QHP_SECT_FILTER_ATTRS  =
975
 

	
976
 
# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
977
 
# be used to specify the location of Qt's qhelpgenerator.
978
 
# If non-empty doxygen will try to run qhelpgenerator on the generated
979
 
# .qhp file.
980
 

	
981
 
QHG_LOCATION           =
982
 

	
983
 
# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
984
 
#  will be generated, which together with the HTML files, form an Eclipse help
985
 
# plugin. To install this plugin and make it available under the help contents
986
 
# menu in Eclipse, the contents of the directory containing the HTML and XML
987
 
# files needs to be copied into the plugins directory of eclipse. The name of
988
 
# the directory within the plugins directory should be the same as
989
 
# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
990
 
# the help appears.
991
 

	
992
 
GENERATE_ECLIPSEHELP   = NO
993
 

	
994
 
# A unique identifier for the eclipse help plugin. When installing the plugin
995
 
# the directory name containing the HTML and XML files should also have
996
 
# this name.
997
 

	
998
 
ECLIPSE_DOC_ID         = org.doxygen.Project
999
 

	
1000
 
# The DISABLE_INDEX tag can be used to turn on/off the condensed index at
1001
 
# top of each HTML page. The value NO (the default) enables the index and
1002
 
# the value YES disables it.
1003
 

	
1004
 
DISABLE_INDEX          = NO
1005
 

	
1006
 
# This tag can be used to set the number of enum values (range [1..20])
1007
 
# that doxygen will group on one line in the generated HTML documentation.
1008
 

	
1009
 
ENUM_VALUES_PER_LINE   = 4
1010
 

	
1011
 
# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
1012
 
# structure should be generated to display hierarchical information.
1013
 
# If the tag value is set to YES, a side panel will be generated
1014
 
# containing a tree-like index structure (just like the one that
1015
 
# is generated for HTML Help). For this to work a browser that supports
1016
 
# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
1017
 
# Windows users are probably better off using the HTML help feature.
1018
 

	
1019
 
GENERATE_TREEVIEW      = NO
1020
 

	
1021
 
# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
1022
 
# used to set the initial width (in pixels) of the frame in which the tree
1023
 
# is shown.
1024
 

	
1025
 
TREEVIEW_WIDTH         = 250
1026
 

	
1027
 
# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
1028
 
# links to external symbols imported via tag files in a separate window.
1029
 

	
1030
 
EXT_LINKS_IN_WINDOW    = NO
1031
 

	
1032
 
# Use this tag to change the font size of Latex formulas included
1033
 
# as images in the HTML documentation. The default is 10. Note that
1034
 
# when you change the font size after a successful doxygen run you need
1035
 
# to manually remove any form_*.png images from the HTML output directory
1036
 
# to force them to be regenerated.
1037
 

	
1038
 
FORMULA_FONTSIZE       = 10
1039
 

	
1040
 
# Use the FORMULA_TRANPARENT tag to determine whether or not the images
1041
 
# generated for formulas are transparent PNGs. Transparent PNGs are
1042
 
# not supported properly for IE 6.0, but are supported on all modern browsers.
1043
 
# Note that when changing this option you need to delete any form_*.png files
1044
 
# in the HTML output before the changes have effect.
1045
 

	
1046
 
FORMULA_TRANSPARENT    = YES
1047
 

	
1048
 
# When the SEARCHENGINE tag is enabled doxygen will generate a search box
1049
 
# for the HTML output. The underlying search engine uses javascript
1050
 
# and DHTML and should work on any modern browser. Note that when using
1051
 
# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
1052
 
# (GENERATE_DOCSET) there is already a search function so this one should
1053
 
# typically be disabled. For large projects the javascript based search engine
1054
 
# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
1055
 

	
1056
 
SEARCHENGINE           = YES
1057
 

	
1058
 
# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
1059
 
# implemented using a PHP enabled web server instead of at the web client
1060
 
# using Javascript. Doxygen will generate the search PHP script and index
1061
 
# file to put on the web server. The advantage of the server
1062
 
# based approach is that it scales better to large projects and allows
1063
 
# full text search. The disadvances is that it is more difficult to setup
1064
 
# and does not have live searching capabilities.
1065
 

	
1066
 
SERVER_BASED_SEARCH    = NO
1067
 

	
1068
 
#---------------------------------------------------------------------------
1069
 
# configuration options related to the LaTeX output
1070
 
#---------------------------------------------------------------------------
1071
 

	
1072
 
# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
1073
 
# generate Latex output.
1074
 

	
1075
 
#GENERATE_LATEX         = YES
1076
 
GENERATE_LATEX         = NO
1077
 

	
1078
 
# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
1079
 
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
1080
 
# put in front of it. If left blank `latex' will be used as the default path.
1081
 

	
1082
 
LATEX_OUTPUT           = latex
1083
 

	
1084
 
# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
1085
 
# invoked. If left blank `latex' will be used as the default command name.
1086
 
# Note that when enabling USE_PDFLATEX this option is only used for
1087
 
# generating bitmaps for formulas in the HTML output, but not in the
1088
 
# Makefile that is written to the output directory.
1089
 

	
1090
 
LATEX_CMD_NAME         = latex
1091
 

	
1092
 
# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
1093
 
# generate index for LaTeX. If left blank `makeindex' will be used as the
1094
 
# default command name.
1095
 

	
1096
 
MAKEINDEX_CMD_NAME     = makeindex
1097
 

	
1098
 
# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
1099
 
# LaTeX documents. This may be useful for small projects and may help to
1100
 
# save some trees in general.
1101
 

	
1102
 
COMPACT_LATEX          = NO
1103
 

	
1104
 
# The PAPER_TYPE tag can be used to set the paper type that is used
1105
 
# by the printer. Possible values are: a4, a4wide, letter, legal and
1106
 
# executive. If left blank a4wide will be used.
1107
 

	
1108
 
PAPER_TYPE             = a4wide
1109
 

	
1110
 
# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
1111
 
# packages that should be included in the LaTeX output.
1112
 

	
1113
 
EXTRA_PACKAGES         =
1114
 

	
1115
 
# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
1116
 
# the generated latex document. The header should contain everything until
1117
 
# the first chapter. If it is left blank doxygen will generate a
1118
 
# standard header. Notice: only use this tag if you know what you are doing!
1119
 

	
1120
 
LATEX_HEADER           =
1121
 

	
1122
 
# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
1123
 
# is prepared for conversion to pdf (using ps2pdf). The pdf file will
1124
 
# contain links (just like the HTML output) instead of page references
1125
 
# This makes the output suitable for online browsing using a pdf viewer.
1126
 

	
1127
 
PDF_HYPERLINKS         = YES
1128
 

	
1129
 
# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
1130
 
# plain latex in the generated Makefile. Set this option to YES to get a
1131
 
# higher quality PDF documentation.
1132
 

	
1133
 
USE_PDFLATEX           = YES
1134
 

	
1135
 
# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
1136
 
# command to the generated LaTeX files. This will instruct LaTeX to keep
1137
 
# running if errors occur, instead of asking the user for help.
1138
 
# This option is also used when generating formulas in HTML.
1139
 

	
1140
 
LATEX_BATCHMODE        = NO
1141
 

	
1142
 
# If LATEX_HIDE_INDICES is set to YES then doxygen will not
1143
 
# include the index chapters (such as File Index, Compound Index, etc.)
1144
 
# in the output.
1145
 

	
1146
 
LATEX_HIDE_INDICES     = NO
1147
 

	
1148
 
# If LATEX_SOURCE_CODE is set to YES then doxygen will include
1149
 
# source code with syntax highlighting in the LaTeX output.
1150
 
# Note that which sources are shown also depends on other settings
1151
 
# such as SOURCE_BROWSER.
1152
 

	
1153
 
LATEX_SOURCE_CODE      = NO
1154
 

	
1155
 
#---------------------------------------------------------------------------
1156
 
# configuration options related to the RTF output
1157
 
#---------------------------------------------------------------------------
1158
 

	
1159
 
# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
1160
 
# The RTF output is optimized for Word 97 and may not look very pretty with
1161
 
# other RTF readers or editors.
1162
 

	
1163
 
GENERATE_RTF           = NO
1164
 

	
1165
 
# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
1166
 
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
1167
 
# put in front of it. If left blank `rtf' will be used as the default path.
1168
 

	
1169
 
RTF_OUTPUT             = rtf
1170
 

	
1171
 
# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
1172
 
# RTF documents. This may be useful for small projects and may help to
1173
 
# save some trees in general.
1174
 

	
1175
 
COMPACT_RTF            = NO
1176
 

	
1177
 
# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
1178
 
# will contain hyperlink fields. The RTF file will
1179
 
# contain links (just like the HTML output) instead of page references.
1180
 
# This makes the output suitable for online browsing using WORD or other
1181
 
# programs which support those fields.
1182
 
# Note: wordpad (write) and others do not support links.
1183
 

	
1184
 
RTF_HYPERLINKS         = NO
1185
 

	
1186
 
# Load stylesheet definitions from file. Syntax is similar to doxygen's
1187
 
# config file, i.e. a series of assignments. You only have to provide
1188
 
# replacements, missing definitions are set to their default value.
1189
 

	
1190
 
RTF_STYLESHEET_FILE    =
1191
 

	
1192
 
# Set optional variables used in the generation of an rtf document.
1193
 
# Syntax is similar to doxygen's config file.
1194
 

	
1195
 
RTF_EXTENSIONS_FILE    =
1196
 

	
1197
 
#---------------------------------------------------------------------------
1198
 
# configuration options related to the man page output
1199
 
#---------------------------------------------------------------------------
1200
 

	
1201
 
# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
1202
 
# generate man pages
1203
 

	
1204
 
GENERATE_MAN           = NO
1205
 

	
1206
 
# The MAN_OUTPUT tag is used to specify where the man pages will be put.
1207
 
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
1208
 
# put in front of it. If left blank `man' will be used as the default path.
1209
 

	
1210
 
MAN_OUTPUT             = man
1211
 

	
1212
 
# The MAN_EXTENSION tag determines the extension that is added to
1213
 
# the generated man pages (default is the subroutine's section .3)
1214
 

	
1215
 
MAN_EXTENSION          = .3
1216
 

	
1217
 
# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
1218
 
# then it will generate one additional man file for each entity
1219
 
# documented in the real man page(s). These additional files
1220
 
# only source the real man page, but without them the man command
1221
 
# would be unable to find the correct page. The default is NO.
1222
 

	
1223
 
MAN_LINKS              = NO
1224
 

	
1225
 
#---------------------------------------------------------------------------
1226
 
# configuration options related to the XML output
1227
 
#---------------------------------------------------------------------------
1228
 

	
1229
 
# If the GENERATE_XML tag is set to YES Doxygen will
1230
 
# generate an XML file that captures the structure of
1231
 
# the code including all documentation.
1232
 

	
1233
 
GENERATE_XML           = NO
1234
 

	
1235
 
# The XML_OUTPUT tag is used to specify where the XML pages will be put.
1236
 
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
1237
 
# put in front of it. If left blank `xml' will be used as the default path.
1238
 

	
1239
 
XML_OUTPUT             = xml
1240
 

	
1241
 
# The XML_SCHEMA tag can be used to specify an XML schema,
1242
 
# which can be used by a validating XML parser to check the
1243
 
# syntax of the XML files.
1244
 

	
1245
 
XML_SCHEMA             =
1246
 

	
1247
 
# The XML_DTD tag can be used to specify an XML DTD,
1248
 
# which can be used by a validating XML parser to check the
1249
 
# syntax of the XML files.
1250
 

	
1251
 
XML_DTD                =
1252
 

	
1253
 
# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
1254
 
# dump the program listings (including syntax highlighting
1255
 
# and cross-referencing information) to the XML output. Note that
1256
 
# enabling this will significantly increase the size of the XML output.
1257
 

	
1258
 
XML_PROGRAMLISTING     = YES
1259
 

	
1260
 
#---------------------------------------------------------------------------
1261
 
# configuration options for the AutoGen Definitions output
1262
 
#---------------------------------------------------------------------------
1263
 

	
1264
 
# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
1265
 
# generate an AutoGen Definitions (see autogen.sf.net) file
1266
 
# that captures the structure of the code including all
1267
 
# documentation. Note that this feature is still experimental
1268
 
# and incomplete at the moment.
1269
 

	
1270
 
GENERATE_AUTOGEN_DEF   = NO
1271
 

	
1272
 
#---------------------------------------------------------------------------
1273
 
# configuration options related to the Perl module output
1274
 
#---------------------------------------------------------------------------
1275
 

	
1276
 
# If the GENERATE_PERLMOD tag is set to YES Doxygen will
1277
 
# generate a Perl module file that captures the structure of
1278
 
# the code including all documentation. Note that this
1279
 
# feature is still experimental and incomplete at the
1280
 
# moment.
1281
 

	
1282
 
GENERATE_PERLMOD       = NO
1283
 

	
1284
 
# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
1285
 
# the necessary Makefile rules, Perl scripts and LaTeX code to be able
1286
 
# to generate PDF and DVI output from the Perl module output.
1287
 

	
1288
 
PERLMOD_LATEX          = NO
1289
 

	
1290
 
# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
1291
 
# nicely formatted so it can be parsed by a human reader.
1292
 
# This is useful
1293
 
# if you want to understand what is going on.
1294
 
# On the other hand, if this
1295
 
# tag is set to NO the size of the Perl module output will be much smaller
1296
 
# and Perl will parse it just the same.
1297
 

	
1298
 
PERLMOD_PRETTY         = YES
1299
 

	
1300
 
# The names of the make variables in the generated doxyrules.make file
1301
 
# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
1302
 
# This is useful so different doxyrules.make files included by the same
1303
 
# Makefile don't overwrite each other's variables.
1304
 

	
1305
 
PERLMOD_MAKEVAR_PREFIX =
1306
 

	
1307
 
#---------------------------------------------------------------------------
1308
 
# Configuration options related to the preprocessor
1309
 
#---------------------------------------------------------------------------
1310
 

	
1311
 
# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
1312
 
# evaluate all C-preprocessor directives found in the sources and include
1313
 
# files.
1314
 

	
1315
 
ENABLE_PREPROCESSING   = YES
1316
 

	
1317
 
# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
1318
 
# names in the source code. If set to NO (the default) only conditional
1319
 
# compilation will be performed. Macro expansion can be done in a controlled
1320
 
# way by setting EXPAND_ONLY_PREDEF to YES.
1321
 

	
1322
 
MACRO_EXPANSION        = YES
1323
 

	
1324
 
# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
1325
 
# then the macro expansion is limited to the macros specified with the
1326
 
# PREDEFINED and EXPAND_AS_DEFINED tags.
1327
 

	
1328
 
EXPAND_ONLY_PREDEF     = YES
1329
 

	
1330
 
# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
1331
 
# in the INCLUDE_PATH (see below) will be search if a #include is found.
1332
 

	
1333
 
SEARCH_INCLUDES        = YES
1334
 

	
1335
 
# The INCLUDE_PATH tag can be used to specify one or more directories that
1336
 
# contain include files that are not input files but should be processed by
1337
 
# the preprocessor.
1338
 

	
1339
 
INCLUDE_PATH           = 
1340
 

	
1341
 
# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
1342
 
# patterns (like *.h and *.hpp) to filter out the header-files in the
1343
 
# directories. If left blank, the patterns specified with FILE_PATTERNS will
1344
 
# be used.
1345
 

	
1346
 
INCLUDE_FILE_PATTERNS  = *.h
1347
 

	
1348
 
# The PREDEFINED tag can be used to specify one or more macro names that
1349
 
# are defined before the preprocessor is started (similar to the -D option of
1350
 
# gcc). The argument of the tag is a list of macros of the form: name
1351
 
# or name=definition (no spaces). If the definition and the = are
1352
 
# omitted =1 is assumed. To prevent a macro definition from being
1353
 
# undefined via #undef or recursively expanded use the := operator
1354
 
# instead of the = operator.
1355
 

	
1356
 
PREDEFINED             = decl_param()=
1357
 

	
1358
 
# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
1359
 
# this tag can be used to specify a list of macro names that should be expanded.
1360
 
# The macro definition that is found in the sources will be used.
1361
 
# Use the PREDEFINED tag if you want to use a different macro definition.
1362
 

	
1363
 
EXPAND_AS_DEFINED      = 
1364
 

	
1365
 
# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
1366
 
# doxygen's preprocessor will remove all function-like macros that are alone
1367
 
# on a line, have an all uppercase name, and do not end with a semicolon. Such
1368
 
# function macros are typically used for boiler-plate code, and will confuse
1369
 
# the parser if not removed.
1370
 

	
1371
 
SKIP_FUNCTION_MACROS   = YES
1372
 

	
1373
 
#---------------------------------------------------------------------------
1374
 
# Configuration::additions related to external references
1375
 
#---------------------------------------------------------------------------
1376
 

	
1377
 
# The TAGFILES option can be used to specify one or more tagfiles.
1378
 
# Optionally an initial location of the external documentation
1379
 
# can be added for each tagfile. The format of a tag file without
1380
 
# this location is as follows:
1381
 
#
1382
 
# TAGFILES = file1 file2 ...
1383
 
# Adding location for the tag files is done as follows:
1384
 
#
1385
 
# TAGFILES = file1=loc1 "file2 = loc2" ...
1386
 
# where "loc1" and "loc2" can be relative or absolute paths or
1387
 
# URLs. If a location is present for each tag, the installdox tool
1388
 
# does not have to be run to correct the links.
1389
 
# Note that each tag file must have a unique name
1390
 
# (where the name does NOT include the path)
1391
 
# If a tag file is not located in the directory in which doxygen
1392
 
# is run, you must also specify the path to the tagfile here.
1393
 

	
1394
 
TAGFILES               =
1395
 

	
1396
 
# When a file name is specified after GENERATE_TAGFILE, doxygen will create
1397
 
# a tag file that is based on the input files it reads.
1398
 

	
1399
 
GENERATE_TAGFILE       =
1400
 

	
1401
 
# If the ALLEXTERNALS tag is set to YES all external classes will be listed
1402
 
# in the class index. If set to NO only the inherited external classes
1403
 
# will be listed.
1404
 

	
1405
 
ALLEXTERNALS           = NO
1406
 

	
1407
 
# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
1408
 
# in the modules index. If set to NO, only the current project's groups will
1409
 
# be listed.
1410
 

	
1411
 
EXTERNAL_GROUPS        = YES
1412
 

	
1413
 
# The PERL_PATH should be the absolute path and name of the perl script
1414
 
# interpreter (i.e. the result of `which perl').
1415
 

	
1416
 
PERL_PATH              = /usr/bin/perl
1417
 

	
1418
 
#---------------------------------------------------------------------------
1419
 
# Configuration options related to the dot tool
1420
 
#---------------------------------------------------------------------------
1421
 

	
1422
 
# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
1423
 
# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
1424
 
# or super classes. Setting the tag to NO turns the diagrams off. Note that
1425
 
# this option is superseded by the HAVE_DOT option below. This is only a
1426
 
# fallback. It is recommended to install and use dot, since it yields more
1427
 
# powerful graphs.
1428
 

	
1429
 
#CLASS_DIAGRAMS         = YES
1430
 
CLASS_DIAGRAMS         = NO
1431
 

	
1432
 
# You can define message sequence charts within doxygen comments using the \msc
1433
 
# command. Doxygen will then run the mscgen tool (see
1434
 
# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
1435
 
# documentation. The MSCGEN_PATH tag allows you to specify the directory where
1436
 
# the mscgen tool resides. If left empty the tool is assumed to be found in the
1437
 
# default search path.
1438
 

	
1439
 
MSCGEN_PATH            =
1440
 

	
1441
 
# If set to YES, the inheritance and collaboration graphs will hide
1442
 
# inheritance and usage relations if the target is undocumented
1443
 
# or is not a class.
1444
 

	
1445
 
#HIDE_UNDOC_RELATIONS   = NO
1446
 
HIDE_UNDOC_RELATIONS   = YES
1447
 

	
1448
 
# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
1449
 
# available from the path. This tool is part of Graphviz, a graph visualization
1450
 
# toolkit from AT&T and Lucent Bell Labs. The other options in this section
1451
 
# have no effect if this option is set to NO (the default)
1452
 

	
1453
 
HAVE_DOT               = YES
1454
 

	
1455
 
# By default doxygen will write a font called FreeSans.ttf to the output
1456
 
# directory and reference it in all dot files that doxygen generates. This
1457
 
# font does not include all possible unicode characters however, so when you need
1458
 
# these (or just want a differently looking font) you can specify the font name
1459
 
# using DOT_FONTNAME. You need need to make sure dot is able to find the font,
1460
 
# which can be done by putting it in a standard location or by setting the
1461
 
# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory
1462
 
# containing the font.
1463
 

	
1464
 
DOT_FONTNAME           = FreeSans
1465
 

	
1466
 
# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
1467
 
# The default size is 10pt.
1468
 

	
1469
 
DOT_FONTSIZE           = 10
1470
 

	
1471
 
# By default doxygen will tell dot to use the output directory to look for the
1472
 
# FreeSans.ttf font (which doxygen will put there itself). If you specify a
1473
 
# different font using DOT_FONTNAME you can set the path where dot
1474
 
# can find it using this tag.
1475
 

	
1476
 
DOT_FONTPATH           =
1477
 

	
1478
 
# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
1479
 
# will generate a graph for each documented class showing the direct and
1480
 
# indirect inheritance relations. Setting this tag to YES will force the
1481
 
# the CLASS_DIAGRAMS tag to NO.
1482
 

	
1483
 
CLASS_GRAPH            = YES
1484
 

	
1485
 
# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
1486
 
# will generate a graph for each documented class showing the direct and
1487
 
# indirect implementation dependencies (inheritance, containment, and
1488
 
# class references variables) of the class with other documented classes.
1489
 

	
1490
 
#COLLABORATION_GRAPH    = YES
1491
 
COLLABORATION_GRAPH    = NO
1492
 

	
1493
 
# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
1494
 
# will generate a graph for groups, showing the direct groups dependencies
1495
 

	
1496
 
GROUP_GRAPHS           = YES
1497
 

	
1498
 
# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
1499
 
# collaboration diagrams in a style similar to the OMG's Unified Modeling
1500
 
# Language.
1501
 

	
1502
 
UML_LOOK               = NO
1503
 

	
1504
 
# If set to YES, the inheritance and collaboration graphs will show the
1505
 
# relations between templates and their instances.
1506
 

	
1507
 
TEMPLATE_RELATIONS     = NO
1508
 

	
1509
 
# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
1510
 
# tags are set to YES then doxygen will generate a graph for each documented
1511
 
# file showing the direct and indirect include dependencies of the file with
1512
 
# other documented files.
1513
 

	
1514
 
INCLUDE_GRAPH          = YES
1515
 

	
1516
 
# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
1517
 
# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
1518
 
# documented header file showing the documented files that directly or
1519
 
# indirectly include this file.
1520
 

	
1521
 
INCLUDED_BY_GRAPH      = YES
1522
 

	
1523
 
# If the CALL_GRAPH and HAVE_DOT options are set to YES then
1524
 
# doxygen will generate a call dependency graph for every global function
1525
 
# or class method. Note that enabling this option will significantly increase
1526
 
# the time of a run. So in most cases it will be better to enable call graphs
1527
 
# for selected functions only using the \callgraph command.
1528
 

	
1529
 
CALL_GRAPH             = YES
1530
 

	
1531
 
# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
1532
 
# doxygen will generate a caller dependency graph for every global function
1533
 
# or class method. Note that enabling this option will significantly increase
1534
 
# the time of a run. So in most cases it will be better to enable caller
1535
 
# graphs for selected functions only using the \callergraph command.
1536
 

	
1537
 
CALLER_GRAPH           = YES
1538
 

	
1539
 
# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
1540
 
# will graphical hierarchy of all classes instead of a textual one.
1541
 

	
1542
 
GRAPHICAL_HIERARCHY    = YES
1543
 

	
1544
 
# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
1545
 
# generated by dot. Possible values are png, jpg, or gif
1546
 
# If left blank png will be used.
1547
 

	
1548
 
DOT_IMAGE_FORMAT       = png
1549
 

	
1550
 
# The tag DOT_PATH can be used to specify the path where the dot tool can be
1551
 
# found. If left blank, it is assumed the dot tool can be found in the path.
1552
 

	
1553
 
DOT_PATH               =
1554
 

	
1555
 
# The DOTFILE_DIRS tag can be used to specify one or more directories that
1556
 
# contain dot files that are included in the documentation (see the
1557
 
# \dotfile command).
1558
 

	
1559
 
DOTFILE_DIRS           =
1560
 

	
1561
 
# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
1562
 
# nodes that will be shown in the graph. If the number of nodes in a graph
1563
 
# becomes larger than this value, doxygen will truncate the graph, which is
1564
 
# visualized by representing a node as a red box. Note that doxygen if the
1565
 
# number of direct children of the root node in a graph is already larger than
1566
 
# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
1567
 
# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
1568
 

	
1569
 
DOT_GRAPH_MAX_NODES    = 50
1570
 

	
1571
 
# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
1572
 
# graphs generated by dot. A depth value of 3 means that only nodes reachable
1573
 
# from the root by following a path via at most 3 edges will be shown. Nodes
1574
 
# that lay further from the root node will be omitted. Note that setting this
1575
 
# option to 1 or 2 may greatly reduce the computation time needed for large
1576
 
# code bases. Also note that the size of a graph can be further restricted by
1577
 
# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
1578
 

	
1579
 
MAX_DOT_GRAPH_DEPTH    = 3
1580
 

	
1581
 
# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
1582
 
# background. This is disabled by default, because dot on Windows does not
1583
 
# seem to support this out of the box. Warning: Depending on the platform used,
1584
 
# enabling this option may lead to badly anti-aliased labels on the edges of
1585
 
# a graph (i.e. they become hard to read).
1586
 

	
1587
 
DOT_TRANSPARENT        = NO
1588
 

	
1589
 
# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
1590
 
# files in one run (i.e. multiple -o and -T options on the command line). This
1591
 
# makes dot run faster, but since only newer versions of dot (>1.8.10)
1592
 
# support this, this feature is disabled by default.
1593
 

	
1594
 
DOT_MULTI_TARGETS      = YES
1595
 

	
1596
 
# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
1597
 
# generate a legend page explaining the meaning of the various boxes and
1598
 
# arrows in the dot generated graphs.
1599
 

	
1600
 
GENERATE_LEGEND        = YES
1601
 

	
1602
 
# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
1603
 
# remove the intermediate dot files that are used to generate
1604
 
# the various graphs.
1605
 

	
1606
 
DOT_CLEANUP            = YES
1607
 

	
1608
 
#  The CITE_BIB_FILES tag can be used to specify one or more bib files
1609
 
#  containing the reference definitions. This must be a list of .bib files.
1610
 
#  The .bib extension is automatically appended if omitted.
1611
 
#  This requires the bibtex tool to be installed. See also
1612
 
#  http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style
1613
 
#  of the bibliography can be controlled using LATEX_BIB_STYLE.
1614
 
#  See also \cite for info how to create references.
1615
 

	
1616
 
CITE_BIB_FILES         = ../markdown/benzi
1617
 

	
1618
 
# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
1619
 
# bibliography, e.g. plainnat, or ieeetr. The default style is plain.
1620
 
# See http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
1621
 

	
1622
 
LATEX_BIB_STYLE       = plain
1623
 

	
1624
 
FORMULA_FONTSIZE	= 12
 
new file 100644
1
 
%!PS-Adobe-3.0
2
 
%%Creator: PyX 0.10
3
 
%%LanguageLevel: 2
4
 
%%DocumentSuppliedResources: (atend)
5
 
%%DocumentMedia: plain 189 252 0 () ()
6
 
%%BoundingBox: 0 0 189 252
7
 
%%Pages: 1
8
 
%%EndComments
9
 
%%BeginDefaults
10
 
%%PageMedia: plain
11
 
%%EndDefaults
12
 
%%BeginProlog
13
 
%%BeginResource: procset xpdf 3.00 0
14
 
%%Copyright: Copyright 1996-2004 Glyph & Cog, LLC
15
 
/xpdf 75 dict def xpdf begin
16
 
% PDF special state
17
 
/pdfDictSize 15 def
18
 
/pdfSetup {
19
 
  3 1 roll 2 array astore
20
 
  /setpagedevice where {
21
 
    pop 3 dict begin
22
 
      /PageSize exch def
23
 
      /ImagingBBox null def
24
 
      { /Duplex true def } if
25
 
    currentdict end setpagedevice
26
 
  } {
27
 
    pop pop
28
 
  } ifelse
29
 
} def
30
 
/pdfStartPage {
31
 
  pdfDictSize dict begin
32
 
  /pdfFillCS [] def
33
 
  /pdfFillXform {} def
34
 
  /pdfStrokeCS [] def
35
 
  /pdfStrokeXform {} def
36
 
  /pdfFill [0] def
37
 
  /pdfStroke [0] def
38
 
  /pdfFillOP false def
39
 
  /pdfStrokeOP false def
40
 
  /pdfLastFill false def
41
 
  /pdfLastStroke false def
42
 
  /pdfTextMat [1 0 0 1 0 0] def
43
 
  /pdfFontSize 0 def
44
 
  /pdfCharSpacing 0 def
45
 
  /pdfTextRender 0 def
46
 
  /pdfTextRise 0 def
47
 
  /pdfWordSpacing 0 def
48
 
  /pdfHorizScaling 1 def
49
 
  /pdfTextClipPath [] def
50
 
} def
51
 
/pdfEndPage { end } def
52
 
% PDF color state
53
 
/cs { /pdfFillXform exch def dup /pdfFillCS exch def
54
 
      setcolorspace } def
55
 
/CS { /pdfStrokeXform exch def dup /pdfStrokeCS exch def
56
 
      setcolorspace } def
57
 
/sc { pdfLastFill not { pdfFillCS setcolorspace } if
58
 
      dup /pdfFill exch def aload pop pdfFillXform setcolor
59
 
     /pdfLastFill true def /pdfLastStroke false def } def
60
 
/SC { pdfLastStroke not { pdfStrokeCS setcolorspace } if
61
 
      dup /pdfStroke exch def aload pop pdfStrokeXform setcolor
62
 
     /pdfLastStroke true def /pdfLastFill false def } def
63
 
/op { /pdfFillOP exch def
64
 
      pdfLastFill { pdfFillOP setoverprint } if } def
65
 
/OP { /pdfStrokeOP exch def
66
 
      pdfLastStroke { pdfStrokeOP setoverprint } if } def
67
 
/fCol {
68
 
  pdfLastFill not {
69
 
    pdfFillCS setcolorspace
70
 
    pdfFill aload pop pdfFillXform setcolor
71
 
    pdfFillOP setoverprint
72
 
    /pdfLastFill true def /pdfLastStroke false def
73
 
  } if
74
 
} def
75
 
/sCol {
76
 
  pdfLastStroke not {
77
 
    pdfStrokeCS setcolorspace
78
 
    pdfStroke aload pop pdfStrokeXform setcolor
79
 
    pdfStrokeOP setoverprint
80
 
    /pdfLastStroke true def /pdfLastFill false def
81
 
  } if
82
 
} def
83
 
% build a font
84
 
/pdfMakeFont {
85
 
  4 3 roll findfont
86
 
  4 2 roll matrix scale makefont
87
 
  dup length dict begin
88
 
    { 1 index /FID ne { def } { pop pop } ifelse } forall
89
 
    /Encoding exch def
90
 
    currentdict
91
 
  end
92
 
  definefont pop
93
 
} def
94
 
/pdfMakeFont16 {
95
 
  exch findfont
96
 
  dup length dict begin
97
 
    { 1 index /FID ne { def } { pop pop } ifelse } forall
98
 
    /WMode exch def
99
 
    currentdict
100
 
  end
101
 
  definefont pop
102
 
} def
103
 
% graphics state operators
104
 
/q { gsave pdfDictSize dict begin } def
105
 
/Q {
106
 
  end grestore
107
 
  /pdfLastFill where {
108
 
    pop
109
 
    pdfLastFill {
110
 
      pdfFillOP setoverprint
111
 
    } {
112
 
      pdfStrokeOP setoverprint
113
 
    } ifelse
114
 
  } if
115
 
} def
116
 
/cm { concat } def
117
 
/d { setdash } def
118
 
/i { setflat } def
119
 
/j { setlinejoin } def
120
 
/J { setlinecap } def
121
 
/M { setmiterlimit } def
122
 
/w { setlinewidth } def
123
 
% path segment operators
124
 
/m { moveto } def
125
 
/l { lineto } def
126
 
/c { curveto } def
127
 
/re { 4 2 roll moveto 1 index 0 rlineto 0 exch rlineto
128
 
      neg 0 rlineto closepath } def
129
 
/h { closepath } def
130
 
% path painting operators
131
 
/S { sCol stroke } def
132
 
/Sf { fCol stroke } def
133
 
/f { fCol fill } def
134
 
/f* { fCol eofill } def
135
 
% clipping operators
136
 
/W { clip newpath } def
137
 
/W* { eoclip newpath } def
138
 
/Ws { strokepath clip newpath } def
139
 
% text state operators
140
 
/Tc { /pdfCharSpacing exch def } def
141
 
/Tf { dup /pdfFontSize exch def
142
 
      dup pdfHorizScaling mul exch matrix scale
143
 
      pdfTextMat matrix concatmatrix dup 4 0 put dup 5 0 put
144
 
      exch findfont exch makefont setfont } def
145
 
/Tr { /pdfTextRender exch def } def
146
 
/Ts { /pdfTextRise exch def } def
147
 
/Tw { /pdfWordSpacing exch def } def
148
 
/Tz { /pdfHorizScaling exch def } def
149
 
% text positioning operators
150
 
/Td { pdfTextMat transform moveto } def
151
 
/Tm { /pdfTextMat exch def } def
152
 
% text string operators
153
 
/cshow where {
154
 
  pop
155
 
  /cshow2 {
156
 
    dup {
157
 
      pop pop
158
 
      1 string dup 0 3 index put 3 index exec
159
 
    } exch cshow
160
 
    pop pop
161
 
  } def
162
 
}{
163
 
  /cshow2 {
164
 
    currentfont /FontType get 0 eq {
165
 
      0 2 2 index length 1 sub {
166
 
        2 copy get exch 1 add 2 index exch get
167
 
        2 copy exch 256 mul add
168
 
        2 string dup 0 6 5 roll put dup 1 5 4 roll put
169
 
        3 index exec
170
 
      } for
171
 
    } {
172
 
      dup {
173
 
        1 string dup 0 3 index put 3 index exec
174
 
      } forall
175
 
    } ifelse
176
 
    pop pop
177
 
  } def
178
 
} ifelse
179
 
/awcp {
180
 
  exch {
181
 
    false charpath
182
 
    5 index 5 index rmoveto
183
 
    6 index eq { 7 index 7 index rmoveto } if
184
 
  } exch cshow2
185
 
  6 {pop} repeat
186
 
} def
187
 
/Tj {
188
 
  fCol
189
 
  1 index stringwidth pdfTextMat idtransform pop
190
 
  sub 1 index length dup 0 ne { div } { pop pop 0 } ifelse
191
 
  pdfWordSpacing pdfHorizScaling mul 0 pdfTextMat dtransform 32
192
 
  4 3 roll pdfCharSpacing pdfHorizScaling mul add 0
193
 
  pdfTextMat dtransform
194
 
  6 5 roll Tj1
195
 
} def
196
 
/Tj16 {
197
 
  fCol
198
 
  2 index stringwidth pdfTextMat idtransform pop
199
 
  sub exch div
200
 
  pdfWordSpacing pdfHorizScaling mul 0 pdfTextMat dtransform 32
201
 
  4 3 roll pdfCharSpacing pdfHorizScaling mul add 0
202
 
  pdfTextMat dtransform
203
 
  6 5 roll Tj1
204
 
} def
205
 
/Tj16V {
206
 
  fCol
207
 
  2 index stringwidth pdfTextMat idtransform exch pop
208
 
  sub exch div
209
 
  0 pdfWordSpacing pdfTextMat dtransform 32
210
 
  4 3 roll pdfCharSpacing add 0 exch
211
 
  pdfTextMat dtransform
212
 
  6 5 roll Tj1
213
 
} def
214
 
/Tj1 {
215
 
  0 pdfTextRise pdfTextMat dtransform rmoveto
216
 
  currentpoint 8 2 roll
217
 
  pdfTextRender 1 and 0 eq {
218
 
    6 copy awidthshow
219
 
  } if
220
 
  pdfTextRender 3 and dup 1 eq exch 2 eq or {
221
 
    7 index 7 index moveto
222
 
    6 copy
223
 
    currentfont /FontType get 3 eq { fCol } { sCol } ifelse
224
 
    false awcp currentpoint stroke moveto
225
 
  } if
226
 
  pdfTextRender 4 and 0 ne {
227
 
    8 6 roll moveto
228
 
    false awcp
229
 
    /pdfTextClipPath [ pdfTextClipPath aload pop
230
 
      {/moveto cvx}
231
 
      {/lineto cvx}
232
 
      {/curveto cvx}
233
 
      {/closepath cvx}
234
 
    pathforall ] def
235
 
    currentpoint newpath moveto
236
 
  } {
237
 
    8 {pop} repeat
238
 
  } ifelse
239
 
  0 pdfTextRise neg pdfTextMat dtransform rmoveto
240
 
} def
241
 
/TJm { pdfFontSize 0.001 mul mul neg 0
242
 
       pdfTextMat dtransform rmoveto } def
243
 
/TJmV { pdfFontSize 0.001 mul mul neg 0 exch
244
 
        pdfTextMat dtransform rmoveto } def
245
 
/Tclip { pdfTextClipPath cvx exec clip newpath
246
 
         /pdfTextClipPath [] def } def
247
 
/Tclip* { pdfTextClipPath cvx exec eoclip newpath
248
 
         /pdfTextClipPath [] def } def
249
 
% Level 2 image operators
250
 
/pdfImBuf 100 string def
251
 
/pdfIm {
252
 
  image
253
 
  { currentfile pdfImBuf readline
254
 
    not { pop exit } if
255
 
    (%-EOD-) eq { exit } if } loop
256
 
} def
257
 
/pdfImM {
258
 
  fCol imagemask
259
 
  { currentfile pdfImBuf readline
260
 
    not { pop exit } if
261
 
    (%-EOD-) eq { exit } if } loop
262
 
} def
263
 
/pr { 2 index 2 index 3 2 roll putinterval 4 add } def
264
 
/pdfImClip {
265
 
  gsave
266
 
  0 2 4 index length 1 sub {
267
 
    dup 4 index exch 2 copy
268
 
    get 5 index div put
269
 
    1 add 3 index exch 2 copy
270
 
    get 3 index div put
271
 
  } for
272
 
  pop pop rectclip
273
 
} def
274
 
/pdfImClipEnd { grestore } def
275
 
% shading operators
276
 
/colordelta {
277
 
  false 0 1 3 index length 1 sub {
278
 
    dup 4 index exch get 3 index 3 2 roll get sub abs 0.004 gt {
279
 
      pop true
280
 
    } if
281
 
  } for
282
 
  exch pop exch pop
283
 
} def
284
 
/funcCol { func n array astore } def
285
 
/funcSH {
286
 
  dup 0 eq {
287
 
    true
288
 
  } {
289
 
    dup 6 eq {
290
 
      false
291
 
    } {
292
 
      4 index 4 index funcCol dup
293
 
      6 index 4 index funcCol dup
294
 
      3 1 roll colordelta 3 1 roll
295
 
      5 index 5 index funcCol dup
296
 
      3 1 roll colordelta 3 1 roll
297
 
      6 index 8 index funcCol dup
298
 
      3 1 roll colordelta 3 1 roll
299
 
      colordelta or or or
300
 
    } ifelse
301
 
  } ifelse
302
 
  {
303
 
    1 add
304
 
    4 index 3 index add 0.5 mul exch 4 index 3 index add 0.5 mul exch
305
 
    6 index 6 index 4 index 4 index 4 index funcSH
306
 
    2 index 6 index 6 index 4 index 4 index funcSH
307
 
    6 index 2 index 4 index 6 index 4 index funcSH
308
 
    5 3 roll 3 2 roll funcSH pop pop
309
 
  } {
310
 
    pop 3 index 2 index add 0.5 mul 3 index  2 index add 0.5 mul
311
 
    funcCol sc
312
 
    dup 4 index exch mat transform m
313
 
    3 index 3 index mat transform l
314
 
    1 index 3 index mat transform l
315
 
    mat transform l pop pop h f*
316
 
  } ifelse
317
 
} def
318
 
/axialCol {
319
 
  dup 0 lt {
320
 
    pop t0
321
 
  } {
322
 
    dup 1 gt {
323
 
      pop t1
324
 
    } {
325
 
      dt mul t0 add
326
 
    } ifelse
327
 
  } ifelse
328
 
  func n array astore
329
 
} def
330
 
/axialSH {
331
 
  dup 0 eq {
332
 
    true
333
 
  } {
334
 
    dup 8 eq {
335
 
      false
336
 
    } {
337
 
      2 index axialCol 2 index axialCol colordelta
338
 
    } ifelse
339
 
  } ifelse
340
 
  {
341
 
    1 add 3 1 roll 2 copy add 0.5 mul
342
 
    dup 4 3 roll exch 4 index axialSH
343
 
    exch 3 2 roll axialSH
344
 
  } {
345
 
    pop 2 copy add 0.5 mul
346
 
    axialCol sc
347
 
    exch dup dx mul x0 add exch dy mul y0 add
348
 
    3 2 roll dup dx mul x0 add exch dy mul y0 add
349
 
    dx abs dy abs ge {
350
 
      2 copy yMin sub dy mul dx div add yMin m
351
 
      yMax sub dy mul dx div add yMax l
352
 
      2 copy yMax sub dy mul dx div add yMax l
353
 
      yMin sub dy mul dx div add yMin l
354
 
      h f*
355
 
    } {
356
 
      exch 2 copy xMin sub dx mul dy div add xMin exch m
357
 
      xMax sub dx mul dy div add xMax exch l
358
 
      exch 2 copy xMax sub dx mul dy div add xMax exch l
359
 
      xMin sub dx mul dy div add xMin exch l
360
 
      h f*
361
 
    } ifelse
362
 
  } ifelse
363
 
} def
364
 
/radialCol {
365
 
  dup t0 lt {
366
 
    pop t0
367
 
  } {
368
 
    dup t1 gt {
369
 
      pop t1
370
 
    } if
371
 
  } ifelse
372
 
  func n array astore
373
 
} def
374
 
/radialSH {
375
 
  dup 0 eq {
376
 
    true
377
 
  } {
378
 
    dup 8 eq {
379
 
      false
380
 
    } {
381
 
      2 index dt mul t0 add radialCol
382
 
      2 index dt mul t0 add radialCol colordelta
383
 
    } ifelse
384
 
  } ifelse
385
 
  {
386
 
    1 add 3 1 roll 2 copy add 0.5 mul
387
 
    dup 4 3 roll exch 4 index radialSH
388
 
    exch 3 2 roll radialSH
389
 
  } {
390
 
    pop 2 copy add 0.5 mul dt mul t0 add
391
 
    radialCol sc
392
 
    encl {
393
 
      exch dup dx mul x0 add exch dup dy mul y0 add exch dr mul r0 add
394
 
      0 360 arc h
395
 
      dup dx mul x0 add exch dup dy mul y0 add exch dr mul r0 add
396
 
      360 0 arcn h f
397
 
    } {
398
 
      2 copy
399
 
      dup dx mul x0 add exch dup dy mul y0 add exch dr mul r0 add
400
 
      a1 a2 arcn
401
 
      dup dx mul x0 add exch dup dy mul y0 add exch dr mul r0 add
402
 
      a2 a1 arcn h
403
 
      dup dx mul x0 add exch dup dy mul y0 add exch dr mul r0 add
404
 
      a1 a2 arc
405
 
      dup dx mul x0 add exch dup dy mul y0 add exch dr mul r0 add
406
 
      a2 a1 arc h f
407
 
    } ifelse
408
 
  } ifelse
409
 
} def
410
 
end
411
 
%%EndResource
412
 
%%EndProlog
413
 
%%BeginSetup
414
 
xpdf begin
415
 
%%BeginResource: font CMR7
416
 
%!PS-AdobeFont-1.0: CMR7 003.002
417
 
%%Title: CMR7
418
 
%Version: 003.002
419
 
%%CreationDate: Mon Jul 13 16:17:00 2009
420
 
%%Creator: David M. Jones
421
 
%Copyright: Copyright (c) 1997, 2009 American Mathematical Society
422
 
%Copyright:  (<http://www.ams.org>), with Reserved Font Name CMR7.
423
 
% This Font Software is licensed under the SIL Open Font License, Version 1.1.
424
 
% This license is in the accompanying file OFL.txt, and is also
425
 
% available with a FAQ at: http://scripts.sil.org/OFL.
426
 
%%EndComments
427
 
FontDirectory/CMR7 known{/CMR7 findfont dup/UniqueID known{dup
428
 
/UniqueID get 5000790 eq exch/FontType get 1 eq and}{pop false}ifelse
429
 
{save true}{false}ifelse}{false}ifelse
430
 
11 dict begin
431
 
/FontType 1 def
432
 
/FontMatrix [0.001 0 0 0.001 0 0 ]readonly def
433
 
/FontName /CMR7 def
434
 
/FontBBox {-27 -250 1122 750 }readonly def
435
 
/PaintType 0 def
436
 
/FontInfo 9 dict dup begin
437
 
/version (003.002) readonly def
438
 
/Notice (Copyright \050c\051 1997, 2009 American Mathematical Society \050<http://www.ams.org>\051, with Reserved Font Name CMR7.) readonly def
439
 
/FullName (CMR7) readonly def
440
 
/FamilyName (Computer Modern) readonly def
441
 
/Weight (Medium) readonly def
442
 
/ItalicAngle 0 def
443
 
/isFixedPitch false def
444
 
/UnderlinePosition -100 def
445
 
/UnderlineThickness 50 def
446
 
end readonly def
447
 
/Encoding 256 array
448
 
0 1 255 { 1 index exch /.notdef put} for
449
 
dup 48 /zero put
450
 
readonly def
451
 
currentdict end
452
 
currentfile eexec
453
 
892db0c466661f5ace3182477f6cfe03c4ecb7c3bcd69df2fb2a2a41c6311ada
454
 
b5598c75c9526ca01f132cee8a0328dddc1c12f4591a4aadc721dde5d6ca2e75
455
 
3ad174cedb36653be8c04790a13510d794abdeade434a069d33c7bfbb9abf7a9
456
 
38439d17a4c580429ea31e28998faec722d6fe5b17cf3b4e0d2f616b0714b605
457
 
0e24f36269072b2a3bef76e8442347855beacd82ae8c084c6c34b92f43789072
458
 
f9cb6d419fa4f58c701787bd08f3cda229d693fbdb8feae19afb8d601a4a80c1
459
 
d2f5378fa0ba44b751da264c145ae8c52e39014e0124f20e9c141cb9393d7689
460
 
139420ab3d0f9c10aac4f670253eeb03dbf10fe689d5f82f32c35d17b505ab57
461
 
63954e8e6822e016b77dfb01e453cf7c0c82a345f95b164d03059fbd7a724674
462
 
fcb5d450eb6ca2478ea0972d354833129ff736a3085d113f94667ec7f6e66f7e
463
 
7fca2703f032d3f1e8194d17e5f9d66e21b23e0356fcde3c0edf90f14a164257
464
 
bd1b4f39b11d6427a1016870468588c56ad0e902282321091b05c1eafb6add8a
465
 
2ac5a0fa8973a1b9269ea354f8ac75b7284af4f089cd79eabc42071ac43dbf23
466
 
2ec7dcf728b23cc369c786eb1ebb21eed0e4f6608a6cb2eff0e722b768a3c8d7
467
 
bee0ba5555d73081462445a016fdc2ee770045933fdc4e22e6394067d9f93d5c
468
 
46b5c1c66871415fa92661d17d9264e89fbff6122906ce84fc4df08a33e529e5
469
 
d3b37aa940355462813b4df8659a91c12e245e49478389d50aeb61fb9a802792
470
 
e1e528ff2db39d9bfc6658e8350605922df51f7e186e066697aed5576249ec2c
471
 
a2f31ecb2b2f675e2e0575329fd585a6be8810ae22cd327351fb5bf4a87671ed
472
 
c78f98d2daeccef3e5c995ff1940e35c128e675e571787395f9c5142145db688
473
 
2d871187b2a1b47ffd2738512131e7dd5a833666e622b1e81c50bdcde060d6de
474
 
4e2bd9021565b8b042dfaa177a723070cca2e817400e7e678152361f6ce22de6
475
 
b8f86c1d6bc979d84a659d24f8c1e48279284ae8e9397f7d338e2a9dffaf691d
476
 
96a91c84d4439dceaff7a98fd0829a21d4adbe649ec4d11a1f141e0fc36b0fb1
477
 
fcad607bfe51a946c2d5b30373bdd4fb87f126b26e025678b4913c2b16d5ebc9
478
 
015f469ac215fd8a5fe1f8853ee1d321914e5c306955e0b2e4d8f1c102f46c5e
479
 
1fdb0f5b3347e085ff6639a7141bcfb1410148b25ded7444f9088daaafa729d6
480
 
cca65c9cd8b2d91a69df15ccc34fd0337b1a5f16ce9d204bdebc628e8dad73f8
481
 
71f1aa33b76dea846271d4ab3f93c5ec266428f1a802a5e4b30c93e03bd6498b
482
 
bafa7a3104e70868b2609baa23626e68cbeda0128e148907a3706721344ad77d
483
 
11b92c05c06e5bd921f042cdffb3ddac4c6c5fc6278418040b0a82cf07febb9a
484
 
7b5a78f9210c59b8fa80c9d027aa27d3b01e7d1507e05c7545a7b3765ee11ea5
485
 
8870770a84596325540ae518c794f0d2dedb932857848b25fcafb8944fb25cc4
486
 
0c1b332391f70aea80dccf3df5714e20ae4c3e402e871aa014ea2ebca4dbc72f
487
 
42b702a7520469411c6809c27b3aa5135c46bd64ec9992d43123b772b592d1df
488
 
c88c183652a638ea17f1875df664da29e7b27da3b0b0f4b860d2f8b3c6b7aacc
489
 
b7bef222b7d7518bc79c31b47d01a253f7cf938d9e6dbed05ce1856889cbf6bf
490
 
83355c22f7cf74db17503fe761e4fdc3efb5cc0124263923a8504d69537a4bc7
491
 
4929db5f404f6078ca37c61a37775cd94eb39709ff40c92553c418373986e935
492
 
87b7d22fe9be308012a725ba59eb2108f21cb5a87471ffe32f094838c1f786bd
493
 
21a551bf59ad3a43f027fe8e7a91aa4f73fef51c8b62aefb268700c2dfbd9752
494
 
bcf6f136acae815c0aa4147aa2ce6d0f9913894704a84b1b0a47fd2524e1eed1
495
 
4947a199d504bd2c61d46d0c5afb5b1bcd238d7a64fc8356ecc91b6a70c69772
496
 
3229c1c5b8521bc99d6c915804510c90f789b4a7184f87285286a9c65345f508
497
 
37b4d55f5c3907d31b5c39ada127d0d6e0fa579b6279214e8805dcee07399722
498
 
f4e79695d48d233a591743df859bbc4006905bbe3bcbf91b8f6668c8ac0e82b5
499
 
c802d16f941210cbc1f0c1397db7f3b25f57a2a8146396113c72314119a79d44
500
 
4f102224b38f5aef24c85bae122f51c6ca99d85d52a058b7881262e71aa8eab4
501
 
e3c8b1a01b84897281c85071d1df152948494b151ddf1d88649e569ecba7c834
502
 
34c4da34e82b13208d5da981a6f84fc53d9bb0f47135c415d37f9e1e640be21a
503
 
28e4ee391fd0bf786611511e34b725d53ef4729b2a7571ef334599cdeb07c7bb
504
 
2e4723edb20c860f754e35096fbc8574230677ad007f63917c85465a0eab7b5f
505
 
a5ccaa47fc3f757243456a89fd2bf15c38b208c6098606b5f14667c63a6493c0
506
 
c3f779c9b6cb8cadc4f9e5cbc2dd30695479959711289441817b64dec64dfece
507
 
b7f9ab7be1277df5a49b2c61388a968e262e6e9b992a33e71c107d6d43b29dbe
508
 
64b2673143a1ee8821ea1a0ac2ff59373f567b02eb3e27bcb3cded713638acaa
509
 
246d5d2034e38ef239e230304579df0190ade195a1233aeb9439f701ec860e1d
510
 
9437d3e5af6784054e2e9821e8f4db3943ffd70126abf5ee3b7626fb822c05db
511
 
db67e9a76ea8d385c7a16ad6e01f2e70b25717529cda6353390118b93355003d
512
 
0f2be7d74527448c050c96955a352bfff89f5781598e029c137def3ff7397c71
513
 
7747f58befcc0c130a0955702d0a82dd8c81e53e311b38aea4848570023b6b9d
514
 
52cc73a210b328132c8e127195a4cc06143b4ef2a1a2b29ada4e314b588ea4b2
515
 
768abf63c269052725b25c7cbd0a3d06c1787cb99064b7dedf6f012e77047037
516
 
920b970bd679c9e243afbd0eb50e59eb96de23a80c7b71affe411db0575fd1ba
517
 
2c6f9229536d6ebc2f7bbe0fab71788b97c628b9dacde872e2a44ebb1a4d1536
518
 
b416d7d5a6a9281e75923c046b41d7b57934a509f4fcddac1f792e193cd8f209
519
 
58f1fd30caa2d7715ec675efcae4893ecb743baed81388c6b12029a7df8f7bba
520
 
3394e11aabde635a7ac07925556c0aed05e39fc132abd2a13d5bb05d502d56d2
521
 
050d1f2016629bb93e9ff43f08ff609fd6f4064ccf273a8f563e1923233213b0
522
 
cec1663edc8e4e4b16f8ec9fa7ff83d644d9fbdbb27fa7cb27ed0256185af0c2