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

#ifndef __HADFLG__
#define __HADFLG__

#include "types.h"

#ifdef __cplusplus
	extern "C" {
#endif

//
//=== hadflg ===========================================================*
//
//
//----------------------------------------------------------------------*
//                                                                      *
//     Copyright (C) 2003-2019:  CERN & INFN                            *
//     All Rights Reserved.                                             *
//                                                                      *
//     Created on 13 September 1991 by    Alfredo Ferrari & Paola Sala  *
//                                                   Infn - Milan       *
//                                                                      *
//     Included in the following routines:                              *
//                                                                      *
//                                         Bdhdr2                       *
//                                         Eventv                       *
//                                         Ferhav                       *
//                                         Hadriv                       *
//                                         Hdncin                       *
//                                         Hhflev                       *
//                                         Hncnev                       *
//                                         Nucdcy                       *
//                                         Nuncln                       *
//                                         Phycrd                       *
//                                         Rchanv                       *
//                                         Twopar                       *
//                                                                      *
//                    Lnwhdr = flag for using the (still on development)*
//                             new Hadriv                               *
//                    Ielflg = Flag to control the elastic channel      *
//                             in Hadriv:                               *
//                             -1: elastic channel reduced according    *
//                                 to a rough Pauli blocking factor     *
//                              0: elastic channel fully accounted for  *
//                             +1: elastic channel suppressed           *
//                    Icxflg = Flag to control the charge exchange      *
//                             channel in Hadriv:                       *
//                             -1: ch. ex. channel reduced according    *
//                                 to a rough Pauli blocking factor     *
//                              0: ch. ex. channel fully accounted for  *
//                             +1: ch. ex. channel suppressed           *
//                    Istflg = Flag to control the strangeness exchange *
//                             channel in Hadriv:                       *
//                             -1: st. ex. channel reduced according    *
//                                 to a rough Pauli blocking factor     *
//                              0: st. ex. channel fully accounted for  *
//                             +1: st. ex. channel suppressed           *
//                    Ianflg = Flag to control the annhiliation channel *
//                             in Hadriv:                               *
//                             -1: annih.  channel only one accounted   *
//                                 for (!!! note please !!!)            *
//                              0: annih.  channel fully accounted for  *
//                             +1: annih.  channel suppressed           *
//             Innure(1,1,k) = Projectile index for the Hadriv reaction *
//                             k (first entrance channel)               *
//             Innure(2,1,k) = Target index for the Hadriv reaction     *
//                             k (first entrance channel)               *
//             Innure(1,2,k) = Projectile index for the Hadriv reaction *
//                             k (second entrance channel, if any)      *
//             Innure(2,2,k) = Target index for the Hadriv reaction     *
//                             k (second entrance channel, if any)      *
//                             It holds:                                *
//                        Nure (Innure(1,j,k),(Innure(2,j,k)/8+1)) = k  *
//                  Areso1/2 = mass   of the 1st/2nd resonance produced *
//                             in Hadriv                                *
//                  Greso1/2 = width  of the 1st/2nd resonance produced *
//                             in Hadriv                                *
//                  Ereso1/2 = energy of the 1st/2nd resonance produced *
//                             in Hadriv                                *
//                  Preso1/2 = momen. of the 1st/2nd resonance produced *
//                             in Hadriv                                *
//              Px,y,zres1/2 = mom. comp. of the 1st/2nd resonance pro- *
//                             duced in Hadrin                          *
//                  Cmszr1/2 = CMS z direction cosine of the 1st/2nd    *
//                             resonance produced in Hadrin             *
//                  Jreso1/2 = index of the 1st/2nd resonance produced  *
//                             in Hadriv                                *
//               Kreso1/2(m) = pointer (inside ...j arrays) of 1st decay*
//                             particles originating from the 1st/2nd   *
//                             resonance produced in Hadriv             *
//                             Kreso.. = k1 + 1000 * k2 + 1000000 * k3  *
//                  Nreso1/2 = number of final particles originating    *
//                             from the 1st/2nd resonance produced in   *
//                             Hadriv                                   *
//                 Aresoj(i) = mass   of the i_th intermediate resonance*
//                             produced in Hadriv                       *
//                 Gresoj(i) = width  of the i_th intermediate resonance*
//                             produced in Hadriv                       *
//                 Eresoj(i) = energy of the i_th intermediate resonance*
//                             produced in Hadriv                       *
//                 Presoj(i) = momen. of the i_th intermediate resonance*
//                             produced in Hadriv                       *
//             Px,y,zresj(i) = mom. comp. of the i_th intermediate reso-*
//                             nance produced in Hadrin                 *
//                 Jresoj(i) = index of the i_th intermediate resonance *
//                             produced in Hadriv                       *
//                 Kresoj(i) = pointer (inside ...j arrays) of the decay*
//                             particles originating from the i_th int- *
//                             ermediate resonance produced in Hadriv   *
//                             Kresoj = k1 + 1000 * k2 + 1000000 * k3   *
//                    Qqreso = Q^2=-t of the resonance creation process *
//                             in Hadriv (projectile and resonance 1)   *
//                    Uureso = u of the resonance creation process in   *
//                             Hadriv (target and resonance 1)          *
//                    Rhresp = local proton  nuclear density (fm^-3)    *
//                    Rhresn = local neutron nuclear density (fm^-3)    *
//                    Lsyman = flag for indistinguishable projectile    *
//                             and target like resonances               *
//                                                                      *
//----------------------------------------------------------------------*
//
const int    MXRSDC = 25;
const double PPAMXB = 0.6E+00;
const double PAUMXB = 2.E+00*0.8E+00;
const double PPAMXM = 0.6E+00;
//
const double PAUMXM = 2.E+00*0.4E+00;
extern struct {
	double	qqreso;
	double	uureso;
	double	rhresp;
	double	rhresn;
	double	aresoj[MXRSDC];
	double	gresoj[MXRSDC];
	double	eresoj[MXRSDC];
	double	presoj[MXRSDC];
	double	pxresj[MXRSDC];
	double	pyresj[MXRSDC];
	double	pzresj[MXRSDC];
	double	cmszrj[MXRSDC];
	int	jresoj[MXRSDC];
	int	kdcrsj[MXRSDC];
	int	ielflg;
	int	icxflg;
	int	istflg;
	int	ianflg;
	int	ioldhd;
	logical	lnwhdr;
	int	innure[16][2][2];
	int	ikchxg[16];
	int	nreso1;
	int	nreso2;
	logical	lsyman;
} hadflg_;


#ifdef __cplusplus
}
#endif
#endif