/*
 * DO NOT MANUALLY UPDATE THIS FILE.
 * If needed: make cpp_headers
 *
 * fortran2c.py - automatic conversion
 *       usrbin.inc -> usrbin.h
 */

#ifndef __USRBIN__
#define __USRBIN__

#include "types.h"

#ifdef __cplusplus
	extern "C" {
#endif

//
//=== usrbin ===========================================================*
//
//----------------------------------------------------------------------*
//                                                                      *
//     Copyright (C) 2003-2019:  CERN & INFN                            *
//     All Rights Reserved.                                             *
//                                                                      *
//     Module USRBIN:                                                   *
//                                                                      *
//     A. Ferrari & A. Fasso': user defined binnings                    *
//                                                                      *
//     Up to MXUSBN user defined binnings are allowed                   *
//            lusbin = logical flag, .true. if at least 1 user defined  *
//                     binning is used                                  *
//            lusevt = logical flag, .true. if at least 1 user defined  *
//                     binning event by event is used                   *
//            lustkb = logical flag, .true. if at least 1 user defined  *
//                     track-length binning is used. Track length bin-  *
//                     ning are recognized as binnings where accurate   *
//                     deposition along the track is requested but      *
//                     for generalized particles other than 208/211     *
//            lusact = logical flag, .true. if at least 1 user defined  *
//                     activity binning is used.                        *
//            lusrsn = logical flag, .true. if at least 1 user defined  *
//                     residual nuclei binning is used.                 *
//            luschr = logical flag, .true. if at least 1 user defined  *
//                     net charge generation binning is used.           *
//            lusqlt = logical flag, .true. if at least 1 user defined  *
//                     eq. dose with Q(L) binning is used.              *
//            lusanh = logical flag, .true. if at least 1 user defined  *
//                     positron annihilation at rest binning is used.   *
//            nusrbn = number of user defined binnings used             *
//            itusbn = type of binning: 0 = cartesian, .ne. 0 = RZ      *
//            idusbn = distribution to be scored: the usual values are  *
//                     allowed.                                         *
//            jdusbn = secondary distribution to be scored: the usual   *
//                     values are allowed                               *
//            titusb = binning name                                     *
//            dequsb = binning name for dose equivalent conversions     *
//            ipusbn = logical unit to print the results on: formatted  *
//                     if > 0, unformatted if < 0                       *
//            kbusbn = initial location in blank common of the consi-   *
//                     dered binning (for index 1, real*8 address for   *
//                     lsngbn = .false., real*4 address for lsngbn      *
//                            = .true.)                                 *
//            nxbin  = number of x (r for RZ) intervals                 *
//            nybin  = number of y (1 for RZ) intervals                 *
//            nzbin  = number of z intervals                            *
//         xlow/high = minimum and maximum x (r   for R-Phi-Z)          *
//         ylow/high = minimum and maximum y (phi for R-Phi-Z)          *
//         zlow/high = minimum and maximum z                            *
//            dxusbn = x (r) bin width                                  *
//            dyusbn = y bin width                                      *
//            dzusbn = z bin width                                      *
//            tcusbn = time cut-off (seconds) for this binning          *
//            clusbn = calibration constant for this binning            *
//                     (meaningful only for energy scoring)             *
//            bkusbn = 1st Birk's law parameter for this binning        *
//                     (meaningful only for energy scoring)             *
//            b2usbn = 2nd Birk's law parameter for this binning        *
//                     (meaningful only for energy scoring)             *
//            xaxusb = x-axis offset for R-Z binning (not possible for  *
//                     R-Phi-Z), just for back-compatibility, now it    *
//                     should be done through rototraslations           *
//            yaxusb = y-axis offset for R-Z binning (not possible for  *
//                     R-Phi-Z), just for back-compatibility, now it    *
//                     should be done through rototraslations           *
//            levtbn = logical flag for binning to be printed at the    *
//                     end of each event only                           *
//            lntzer = logical flag for printing only non zero cells    *
//            lifnzr = logical flag for printing only if there are non  *
//                     zero cells                                       *
//            ltrkbn = logical flag for flagging track-length binnings  *
//            lsngbn = logical flag for single precision storing of     *
//                     data                                             *
//            lrmabn = logical flag for reduced memory allocation of    *
//                     data                                             *
//            narmbn = number of allocated cells for reduced memory     *
//                     allocation binnings                              *
//            nusdbn = number of used cells for reduced memory alloca-  *
//                     tion binnings or non zero printout binnings      *
//            nusbmx = highest used cell address for non zero printout  *
//                     binnings                                         *
//            nusbmn = lowest  used cell address for non zero printout  *
//                     binnings                                         *
//            ncasbn = number of events after which results must be     *
//                     printed for EVENTBIN estimators                  *
//            ibiobn = index of the cellular line radiobiological info  *
//                     to be associated to a given binning              *
//            iroibn = index of the possible ROI to be associated to    *
//                     this binning                                     *
//            kausbn = initial location in blank common of cell indeces *
//                     for a reduced memory allocation binning (for     *
//                     index 1, integer*4 address)                      *
//            krtnbn = flag of a possible pre-defined rotation (if >0)  *
//                     to be applied to the binnings before scoring     *
//            kdcyub = flag for radioactive decay scoring (-1=prompt +  *
//                     all radioactive decays, 0=prompt only, i=i_th    *
//                     decay time only)                                 *
//            krcfub = flag for which density correction factors to be  *
//                     used for "per unit mass" binnings:               *
//                     0 = density correction factors (default for all  *
//                         binnings apart 252 (DOSE-H2O), 253 (ALPHA-D) *
//                         and 254 (SQBETA-D))                          *
//                     1 = dE/dX correction factors (default for        *
//                         the 252 (DOSE-H2O), 253 (ALPHA-D) and        *
//                         254 (SQBETA-D) binnings)                     *
//            linzal = true if all eventbin's are to be printed only if *
//                     there are non-zero cells                         *
//            lebpnw = true if at least one eventbin info has been      *
//                     printed for the current event                    *
//                                                                      *
//----------------------------------------------------------------------*
//
const int    MXUSBN = 400;
extern struct {
	double	xlow[MXUSBN];
	double	xhigh[MXUSBN];
	double	ylow[MXUSBN];
	double	yhigh[MXUSBN];
	double	zlow[MXUSBN];
	double	zhigh[MXUSBN];
	double	dxusbn[MXUSBN];
	double	dyusbn[MXUSBN];
	double	dzusbn[MXUSBN];
	double	tcusbn[MXUSBN];
	double	clusbn[MXUSBN];
	double	bkusbn[MXUSBN];
	double	b2usbn[MXUSBN];
	double	xaxusb[MXUSBN];
	double	yaxusb[MXUSBN];
	int	nxbin[MXUSBN];
	int	nybin[MXUSBN];
	int	nzbin[MXUSBN];
	int	itusbn[MXUSBN];
	int	idusbn[MXUSBN];
	int	jdusbn[MXUSBN];
	int	kbusbn[MXUSBN];
	int	kausbn[MXUSBN];
	int	ipusbn[MXUSBN];
	int	krtnbn[MXUSBN];
	int	kdcyub[MXUSBN];
	int	krcfub[MXUSBN];
	int	narmbn[MXUSBN];
	int	nusdbn[MXUSBN];
	int	ncasbn[MXUSBN];
	int	nusbmx[MXUSBN];
	int	nusbmn[MXUSBN];
	int	ibiobn[MXUSBN];
	int	iroibn[MXUSBN];
	logical	levtbn[MXUSBN];
	logical	lntzer[MXUSBN];
	logical	lifnzr[MXUSBN];
	logical	lsngbn[MXUSBN];
	logical	ltrkbn[MXUSBN];
	logical	lrmabn[MXUSBN];
	logical	lmombn[MXUSBN];
	int	nusrbn;
	logical	lusbin;
	logical	lusevt;
	logical	lustkb;
	logical	lusmxb;
	logical	lusmyb;
	logical	lusmzb;
	logical	lusmrb;
	logical	lusmpb;
	logical	lusact;
	logical	lusrsn;
	logical	luschr;
	logical	lusqlt;
	logical	lusanh;
	logical	linzal;
	logical	lebpnw;
} usrbn_;

extern struct {
	char	titusb[MXUSBN][10];
	char	dequsb[MXUSBN][10];
} usrch_;


#ifdef __cplusplus
}
#endif
#endif