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

#ifndef __FRBKCM__
#define __FRBKCM__

#include "types.h"

#ifdef __cplusplus
	extern "C" {
#endif

//
//=== frbkcm ===========================================================*
//
//----------------------------------------------------------------------*
//                                                                      *
//     Copyright (C) 2003-2019:  CERN & INFN                            *
//     All Rights Reserved.                                             *
//                                                                      *
//     FeRmi BreaKup CoMmon:                                            *
//                                                                      *
//     Created on 10 February 1995  by    Alfredo Ferrari & Paola Sala  *
//                                                 Infn - Milan         *
//                                                                      *
//     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!      *
//     !!!!                                                   !!!!      *
//     !!!!   Energy, momentum and mass units of the Fermi    !!!!      *
//     !!!!   break-up algorithm are MeV, MeV/c, and MeV/c^2  !!!!      *
//     !!!!   respectively                                    !!!!      *
//     !!!!                                                   !!!!      *
//     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!      *
//                                                                      *
//              Lfrmbk = Logical flag for activating the Fermi Break-Up *
//                       algorithm                                      *
//              Amufbk = Atomic/Nuclear mass unit for the Fermi breakup *
//                       algorithm (it must be consistent with Lncmss   *
//                       and the recorded mas excesses)                 *
//              Lncmss = Logical flag for nuclear (.true.) or atomic    *
//                       masses                                         *
//          Eexfbk (j) = excitation energy (MeV) of the jth particle    *
//                       stable state                                   *
//          Weifbk (j) = weight of the jth particle stable state        *
//                       (used if a broad state is split into several   *
//                        partial contributions)                        *
//          Gamfbk (j) = width (MeV) of the jth particle stable state   *
//                       (Gamma tau = hbar)                             *
//          Amfrbk (j) = total atomic/nuclear mass of the jth particle  *
//                       stable state                                   *
//              Exmxfb = Maximum excess mass to be used to build the    *
//                       break up channels                              *
//              Nbufbk = The above restriction is used only if the total*
//                       estimated number of break up channels is larger*
//                       than Nbufbk                                    *
//       Rcbfbk(in,iz) = radius (fm) for in.iz (gs) to be used in centr-*
//                       ifugal barrier calculations                    *
//              R0frbk = R0 for the interaction volume                  *
//              R0bfbk = R0 for the centrifugal barrier among fragments *
//              R0cfbk = R0 for the Coulomb potential among fragments   *
//              C1cfbk = C1 for the Coulomb potential among fragments   *
//              C2cfbk = C2 for the Coulomb potential among fragments   *
//              Rewfbk = factor used when considering whether wide      *
//                       levels should be used or not depending on the  *
//                       currently available excitation energy          *
//                       P_use = 1 - exp[-Rewfbk (Eex - Width) / Width] *
//              Lewfbk = flag for considering rather than not wide      *
//                       levels depending on the currently available    *
//                       excitation energy                              *
//          Ifrbkn (j) = neutron number of the jth particle stable state*
//          Ifrbkz (j) = atomic  number of the jth particle stable state*
//          Ifbksp (j) = spin (in hbar/2 unit) of the jth particle      *
//                       stable state                                   *
//          Ifbkpr (j) = parity of the jth particle stable state        *
//          Ifbkst (j) = stability index of the jth particle stable     *
//                       state                                          *
//          Ifbklv (j) = level number in the nuclear level database for *
//                       the jth particle stable state                  *
//       Exjpfb(in,iz) = maximum excitation energy for which spin/parity*
//                       assignments based on stable states makes sense *
//                       for states with N=in and Z=iz                  *
//    Ipsind (in,iz,1) = starting index of the particle stable states   *
//                       with N=in and Z=iz                             *
//    Ipsind (in,iz,2) = last index of the particle stable states with  *
//                       N=in and Z=iz                                  *
//         Jpsind (ia) = last index of the particle stable states with  *
//                       A=ia                                           *
//          Exfrbk (i) = total mass excess of the ith break-up          *
//          Sdmfbk (i) = (global) spin, degeneracy and mass factor      *
//                       of the ith break-up                            *
//          Coufbk (i) = (global) Coulomb energy of the ith break-up    *
//          Cenfbk (i) = (global) centrifugal barrier of the ith break  *
//                       -up (to be multiplied by l(l+1) )              *
//          Geffbk (i) = effective width of the of the ith break-up     *
//        Ifbcha (1,i) = N of the ith break up combination              *
//        Ifbcha (2,i) = Z of the ith break up combination              *
//        Ifbcha (3,i) = first  particle to be emitted                  *
//        Ifbcha (4,i) = second particle to be emitted (if negative it  *
//                       is a combination of particles of index=| |)    *
//        Ifbcha (5,i) = (global) multiplicity of the ith break-up      *
//        Ifbcha (6,i) = Minimum, (2)Jmin, and Maximum, (2)Jmax, angu-  *
//                       lar momentum (2)J (in hbar/2 units) (for L=0   *
//                       orbital momentum) of the ith break-up, encoded *
//                       as: (2)Jmin + 1000 x (2)Jmax                   *
//        Ifbcha (7,i) = Multiplicity of angular momentum J encoded as: *
//                              m(Jmin) IB^0 + m(Jmin+1) IB^1 + ....    *
//                       .... + m(Jmax-1) IB^(Jmax-Jmin-1)              *
//                            + m(Jmax) IB^(Jmax-Jmin)                  *
//                       J total multiplicity = (2J+1) x m(J)           *
//                       where the base IB is given by the parameter    *
//                       IBFRBK, if Jmax-Jmin > Jpwfbx an underflow     *
//                       would result, therefore the remaining part is  *
//                       endcoded into:                                 *
//        Ifbcha (8,i) = Multiplicity of angular momentum J, 2nd part   *
//                       .... + m(Jmax-1) IB^(Jmax-Jmin-Jpwfbx-2)       *
//                            + m(Jmax) IB^(Jmax-Jmin-Jpwfbx-1)         *
//                       The allowed maximum number of different J      *
//                       values (Jmax-Jmin+1) is so 2*(Jpwfbx+1)        *
//        Ifbcha (9,i) = Parity/(-1)^L (L orbital momentum) of the ith  *
//                       break-up                                       *
//    Ifbind (in,iz,1) = starting index of the break up combinations    *
//                       with N=in and Z=iz                             *
//    Ifbind (in,iz,2) = last index of the break up combinations with   *
//                       N=in and Z=iz                                  *
//         Jfbind (ia) = last index of the break up combinations with   *
//                       A=ia                                           *
//              Iposst = total number of possible particle stable states*
//              Iposfb = total number of possible break up combinations *
//              Ifbstf = flag for level of inclusion of stable levels   *
//                       Ifbstf = i0 + i1 x 100                         *
//              Ifbpsf = flag for parity-spin effects:                  *
//                    -1 : no account                                   *
//                     0 : L=0 fully accounted for, channels with L>=1  *
//                         suppressed by FRBKLS^L (in practice they are *
//                         retained only if no L=0 channel is available)*
//                 0 < L': reasonable centrifugal barrier account up    *
//                         to orbital momentum L=L', as above for L>L'  *
//              Ifbpsi = flag for which initial configurations to       *
//                       consider for parity-spin  effects              *
//                     0 : consider only initial configurations with    *
//                         known spin/parity and no particle emitted    *
//                         or intiial configurations which fall into    *
//                         the energy range of available states         *
//                     1 : consider only initial configurations with    *
//                         known spin/parity and no particle emitted    *
//                         or intiial configurations which fall into    *
//                         the energy range of available states res-    *
//                         tricted to really semi-stable states, those  *
//                         below Exjpfb                                 *
//                    10 : consider all  initial configurations maybe   *
//                         performing some educated guess on spin/parity*
//                         for the rest like 0                          *
//                    11 : consider all  initial configurations maybe   *
//                         performing some educated guess on spin/parity*
//                         for the rest like 1                          *
//              Frbkls = suppression factor for L>Lmax to be cosidered  *
//                       for orbital momentum barriers                  *
//              Ifbfrb = (possible) forbidden "particle stable" state   *
//              Ifbchn = (possible) forced break up channel             *
//              Ifbnc1 = (possible) forbidden break up channel          *
//              Ifbnc2 = (possible) forbidden break up channel          *
//                                                                      *
//----------------------------------------------------------------------*
//
//  Maximum number of fragments to be emitted:
const int    MXFFBK = 6;
const int    MXZFBK = 10;
const int    MXNFBK = 12;
const int    MXAFBK = 16;
const int    MXASST = 25;
const int    NXAFBK = MXAFBK+1;
const int    NXZFBK = INT(MXZFBK+MXFFBK/3+MXASST-NXAFBK);
//  Maximum number of "stable" particle states
const int    NXNFBK = INT(MXNFBK+MXFFBK/3+MXASST-NXAFBK);
//  Maximum number of pre-computed break-up combinations
const int    MXPSST = 700;
//  Maximum number of break-up combinations, including special
//  run-time ones:
const int    MXPPFB = 42500;
//  Base for J multiplicity encoding:
const int    MXPSFB = 43000;
//  Maximum Ibfrbk exponent to avoid overflow of I*4(roughly at 2.1x10^9)
//  it must be (Ibfrbk-1) + (Ibfrbk-1)*Ibfrbk + (Ibfrbk-1)*Ibfrbk^2 + ...
//  ... + (Ibfrbk-1)*Ibfrbk^Jpwfbx < 2100000000,
//  --> Ibfrbk^(Jpwfbx+1) < 2100000000
const int    IBFRBK = 73;
const int    JPWFBX = 4;
extern struct {
	double	amufbk;
	double	eexfbk[MXPSST];
	double	amfrbk[MXPSST];
	double	weifbk[MXPSST];
	double	gamfbk[MXPSST];
	double	exfrbk[MXPSFB];
	double	sdmfbk[MXPSFB];
	double	coufbk[MXPSFB];
	double	cenfbk[MXPSFB];
	double	geffbk[MXPSFB];
	double	rcbfbk[NXZFBK+1+1][NXNFBK+1+1];
	double	exjpfb[NXZFBK+1+1][NXNFBK+1+1];
	double	exmxfb;
	double	r0frbk;
	double	r0bfbk;
	double	r0cfbk;
	double	c1cfbk;
	double	c2cfbk;
	double	frbkls;
	double	rewfbk;
	int	ifrbkn[MXPSST];
	int	ifrbkz[MXPSST];
	int	ifbksp[MXPSST];
	int	ifbkpr[MXPSST];
	int	ifbkst[MXPSST];
	int	ifbklv[MXPSST];
	int	ipsind[2][NXZFBK+1][NXNFBK+1];
	int	jpsind[MXASST+1];
	int	ifbind[2][NXZFBK+1][NXNFBK+1];
	int	jfbind[NXAFBK+1];
	int	ifbcha[MXPSFB][9];
	int	iposst;
	int	iposfb;
	int	ifbstf;
	int	ifbpsf;
	int	ifbpsi;
	int	ifbfrb;
	int	ifbchn;
	int	ifbnc1;
	int	ifbnc2;
	int	nbufbk;
	logical	lfrmbk;
	logical	lncmss;
	logical	lewfbk;
} frbkcm_;
const int frbkcm_rcbfbk_base = -1;
const int frbkcm_exjpfb_base = -1;
const int frbkcm_ipsind_base = 0;
const int frbkcm_jpsind_base = 0;
const int frbkcm_ifbind_base = 0;
const int frbkcm_jfbind_base = 0;


#ifdef __cplusplus
}
#endif
#endif