DintEMCascade::DintEMCascade(int _aIRFlag, int _aRadioFlag, string _aDirTables,
double B, double _aH0, double _aOmegaM, double
_aOmegaLambda) : synchrotronSwitch(1), sourceTypeSwitch(0),
tauNeutrinoMassSwitch(1), ICSSwitch(1), PPSwitch(1), TPPSwitch(1),
DPPSwitch(1), PPPSwitch(0), NPPSwitch(0), neutronDecaySwitch(0),
nucleonToSecondarySwitch(0), neutrinoNeutrinoSwitch(0), aIRFlag(_aIRFlag),
aRadioFlag(_aRadioFlag), aH0(_aH0), aOmegaM(_aOmegaM),
aOmegaLambda(_aOmegaLambda), aZmax_IR(5.), aDirTables(_aDirTables)
{
BuildRedshiftTable(aH0, aOmegaM, aOmegaLambda, &RedshiftArray, &DistanceArray) ;
// Initialize the bField
New_dCVector(&pB_field, 1);
for (size_t i = 0; i < 1; i++)
pB_field.vector[i] = B; // B in gauss
//-------- Set up energy bins --------
New_dCVector(&deltaG, NUM_MAIN_BINS);
New_dCVector(&bgEnergy, NUM_BG_BINS);
New_dCVector(&bgEnergyWidth, NUM_BG_BINS);
New_dCVector(&bgPhotonDensity, NUM_BG_BINS);
New_dCVector(&pEnergy, NUM_MAIN_BINS);
New_dCVector(&pEnergyWidth, NUM_MAIN_BINS);
SetEnergyBins(MIN_ENERGY_EXP, &pEnergy, &pEnergyWidth);
// set energy bins
SetDeltaG(&pEnergy, &deltaG);
SetEnergyBins(BG_MIN_ENERGY_EXP, &bgEnergy, &bgEnergyWidth);
NewSpectrum(&Q_0, NUM_MAIN_BINS);
NewSpectrum(&spectrumNew, NUM_MAIN_BINS);
NewSpectrum(&derivative, NUM_MAIN_BINS);
New_dCVector(&synchrotronLoss, NUM_MAIN_BINS);
New_dCVector(&otherLoss, NUM_MAIN_BINS);
New_dCVector(&continuousLoss, NUM_MAIN_BINS);
if (ICSSwitch == 1) {
NewRawTotalRate(&ICSTotalRate, EM_NUM_MAIN_BINS, NUM_BG_BINS);
NewRawDiffRate(&ICSPhotonRate, EM_NUM_MAIN_BINS, NUM_BG_BINS,
NUM_IP_ELEMENTS);
NewRawDiffRate(&ICSScatRate, EM_NUM_MAIN_BINS, NUM_BG_BINS,
NUM_IS_ELEMENTS);
}
if (PPSwitch == 1) {
NewRawTotalRate(&PPTotalRate, EM_NUM_MAIN_BINS, NUM_BG_BINS);
NewRawDiffRate(&PPDiffRate, EM_NUM_MAIN_BINS, NUM_BG_BINS,
NUM_PP_ELEMENTS);
}
if (TPPSwitch == 1) {
NewRawTotalRate(&TPPTotalRate, EM_NUM_MAIN_BINS, NUM_BG_BINS);
NewRawDiffRate(&TPPDiffRate, EM_NUM_MAIN_BINS, NUM_BG_BINS,
NUM_TPP_ELEMENTS);
}
if (DPPSwitch == 1)
NewRawTotalRate(&DPPRate, EM_NUM_MAIN_BINS, NUM_BG_BINS);
//---- read in coefficient tables; clipping is done here if necessary ----
if (ICSSwitch == 1)
LoadICSTables(&ICSTotalRate, &ICSPhotonRate, &ICSScatRate,
NUM_MAIN_BINS, aDirTables);
if (PPSwitch == 1)
LoadPPTables(&PPTotalRate, &PPDiffRate, NUM_MAIN_BINS, aDirTables);
if (TPPSwitch == 1)
LoadTPPTables(&TPPTotalRate, &TPPDiffRate, NUM_MAIN_BINS, aDirTables);
if (DPPSwitch == 1)
LoadDPPTables(&DPPRate, NUM_MAIN_BINS, aDirTables);
NewTotalRate(&leptonTotalRate, NUM_MAIN_BINS);
NewTotalRate(&photonTotalRate, NUM_MAIN_BINS);
NewTotalRate(&protonTotalRate, NUM_MAIN_BINS);
NewTotalRate(&neutronTotalRate, NUM_MAIN_BINS);
NewDiffRate(&leptonScatRate, NUM_MAIN_BINS);
NewDiffRate(&leptonExchRate, NUM_MAIN_BINS);
NewDiffRate(&leptonPhotonRate, NUM_MAIN_BINS);
NewDiffRate(&photonLeptonRate, NUM_MAIN_BINS);
NewDiffRate(&protonScatRate, NUM_MAIN_BINS);
NewDiffRate(&protonNeutronRate, NUM_MAIN_BINS);
NewDiffRate(&neutronProtonRate, NUM_MAIN_BINS);
NewDiffRate(&protonPhotonRate, NUM_MAIN_BINS);
NewDiffRate(&protonElectronRate, NUM_MAIN_BINS);
NewDiffRate(&protonPositronRate, NUM_MAIN_BINS);
NewDiffRate(&neutronElectronRate, NUM_MAIN_BINS);
NewDiffRate(&neutronPositronRate, NUM_MAIN_BINS);
NewDiffRate(&protonElectronNeutrinoRate, NUM_MAIN_BINS);
NewDiffRate(&protonAntiElectronNeutrinoRate, NUM_MAIN_BINS);
NewDiffRate(&protonMuonNeutrinoRate, NUM_MAIN_BINS);
NewDiffRate(&protonAntiMuonNeutrinoRate, NUM_MAIN_BINS);
NewDiffRate(&neutronAntiElectronNeutrinoRate, NUM_MAIN_BINS);
NewDiffRate(&neutronMuonNeutrinoRate, NUM_MAIN_BINS);
NewDiffRate(&neutronAntiMuonNeutrinoRate, NUM_MAIN_BINS);
NewTotalRate(&elNeutTotalRate, NUM_MAIN_BINS);
NewTotalRate(&muonNeutTotalRate, NUM_MAIN_BINS);
NewTotalRate(&tauNeutTotalRate, NUM_MAIN_BINS);
NewDiffRate(&elNeutElectronRate, NUM_MAIN_BINS);
NewDiffRate(&elNeutPhotonRate, NUM_MAIN_BINS);
NewDiffRate(&muonNeutElectronRate, NUM_MAIN_BINS);
NewDiffRate(&muonNeutPhotonRate, NUM_MAIN_BINS);
NewDiffRate(&tauNeutElectronRate, NUM_MAIN_BINS);
NewDiffRate(&tauNeutPhotonRate, NUM_MAIN_BINS);
}
void prop_second(const double dist_observer,
//const double InjEnergy,
//const PARTICLE part,
//const double HInjEnergy, const double deltaE_hadron,
const dCVector* pB_field,
const dCVector* pEnergy,
const dCVector* pEnergyWidth,
Spectrum* apInjectionSpectrum,
Spectrum* pSpectrum,
string aDirTables,
const int aIRFlag, const double aZmax_IR, const int aRadioFlag,
const double aH0 = H_0, const double aOmegaM = OMEGA_M,
const double aOmegaLambda = OMEGA_LAMBDA,
const double aCutcascade_Magfield = 0) {
//-------- Declaration of main variables --------
//---- Interaction table coefficients ----
RawTotalRate ICSTotalRate;
RawTotalRate PPTotalRate;
RawTotalRate TPPTotalRate;
RawTotalRate DPPRate;
RawTotalRate PPPProtonLossRate;
RawTotalRate PPPNeutronLossRate;
RawTotalRate NPPTotalRate;
// total (interaction) rates before being folded into the background
RawDiffRate ICSPhotonRate;
RawDiffRate ICSScatRate;
RawDiffRate PPDiffRate;
RawDiffRate TPPDiffRate;
RawDiffRate PPPProtonScatRate;
RawDiffRate PPPProtonNeutronRate;
RawDiffRate PPPNeutronProtonRate;
RawDiffRate PPPProtonPhotonRate;
RawDiffRate PPPProtonElectronRate;
RawDiffRate PPPProtonPositronRate;
RawDiffRate PPPNeutronElectronRate;
RawDiffRate NPPDiffRate;
RawDiffRate PPPProtonElectronNeutrinoRate;
RawDiffRate PPPProtonAntiElectronNeutrinoRate;
RawDiffRate PPPProtonMuonNeutrinoRate;
RawDiffRate PPPProtonAntiMuonNeutrinoRate;
RawDiffRate PPPNeutronAntiElectronNeutrinoRate;
RawDiffRate PPPNeutronMuonNeutrinoRate;
RawDiffRate PPPNeutronAntiMuonNeutrinoRate;
// differential rates before being folded into the background
TotalRate neutronDecayRate;
DiffRate neutronDecayElectronRate;
DiffRate neutronDecayProtonRate;
TotalRate NNElNeutTotalRate;
TotalRate NNMuonNeutTotalRate;
TotalRate NNTauNeutTotalRate;
// These total rates are net rates; i.e. scattered flux into same bin is subtracted
DiffRate NNElNeutScatRate;
DiffRate NNElNeutMuonNeutRate;
DiffRate NNElNeutTauNeutRate;
DiffRate NNElNeutElectronRate;
DiffRate NNElNeutPhotonRate;
DiffRate NNElNeutProtonRate;
DiffRate NNMuonNeutScatRate;
DiffRate NNMuonNeutElNeutRate;
DiffRate NNMuonNeutTauNeutRate;
DiffRate NNMuonNeutElectronRate;
DiffRate NNMuonNeutPhotonRate;
DiffRate NNMuonNeutProtonRate;
DiffRate NNTauNeutScatRate;
DiffRate NNTauNeutElNeutRate;
DiffRate NNTauNeutMuonNeutRate;
DiffRate NNTauNeutElectronRate;
DiffRate NNTauNeutPhotonRate;
DiffRate NNTauNeutProtonRate;
// rates from neutrino-neutrino interaction
//---- Main parameter variables ----
int B_bin, B_bins; // bin numbers for B-field array
dCVector deltaG; // dg used in continuous energy loss calculation
dCVector bgEnergy;
dCVector bgEnergyWidth;
dCVector bgPhotonDensity;
double distance; // main distance variable (cm)
int numSmallSteps; // number of small steps in one redshift step
double convergeParameter; // redshift increment
int synchrotronSwitch;
double B_loc; // local strength of extragalactic magnetic field (gauss)
DiffRate syncRate;
int sourceTypeSwitch; // source type: single (0) or diffuse (1)
double brightPhaseExp; // bright phase exponent
double startingRedshift; // zsource in FORTRAN
double minDistance; // minimal distance to sources
double bkgFactor; // local background enhancement factor
double totalEnergyInput; // einj0 in FORTRAN
Spectrum Q_0; // standard injection function
Spectrum spectrumNew;
Spectrum derivative;
double initialPhotonEnergy; // totpe in FORTRAN
double initialLeptonEnergy; // totee
double initialNucleonEnergy;
double initialNeutrinoEnergy;
double initialTotalEnergy; // tote
double initialPhotonNumber; // totpn
double initialLeptonNumber; // toten
double initialNucleonNumber;
double initialNeutrinoNumber;
double initialTotalNumber; // totn
int iterationCounter; // niter in FORTRAN
int firstIndex; // ifirst
double leftRedshift; // zi
double deltaRedshift; //zdelt
int lastIndex; // ilast
double propagatingDistance;
// totalx: total propagating distance (pc)
double rightRedshift; // zf
double centralRedshift; // zt
double redshiftRatio; // erat
// double tempCoefficient; // coeff
double distanceStep; // tzdist*tdz (cm)
double rightDistance; // d1 (Mpc)
double leftDistance; // d2 (Mpc)
double evolutionFactor,evolutionFactor1; // zfact
double smallDistanceStep; // dx (pc)
double x; // x (pc)
// Energy below which the 1D approximation is not a priori correct :
bool lEcFlag ;
int lIndex ;
double lEnergy, t_sync, t_larmor, t_ics = 0 ;
double a_ics = (3.-log10(4.))/4. ;
double b_ics = pow(10.,8.-7.*a_ics) ;
// (used if the flag aCutcascade_Magfield is set)
// FILE* input;
int tauNeutrinoMassSwitch;
// interaction switches
int ICSSwitch;
int PPSwitch;
int TPPSwitch;
int DPPSwitch;
int PPPSwitch;
int NPPSwitch;
int neutronDecaySwitch;
int nucleonToSecondarySwitch;
int neutrinoNeutrinoSwitch;
//---- interaction rates folded with photon background ----
TotalRate leptonTotalRate;
TotalRate photonTotalRate;
TotalRate protonTotalRate;
TotalRate neutronTotalRate;
DiffRate leptonScatRate;
DiffRate leptonExchRate;
DiffRate leptonPhotonRate;
DiffRate photonLeptonRate;
DiffRate protonScatRate;
DiffRate protonNeutronRate;
DiffRate neutronProtonRate;
DiffRate protonPhotonRate;
DiffRate protonElectronRate;
DiffRate protonPositronRate;
DiffRate neutronElectronRate;
DiffRate neutronPositronRate;
DiffRate protonElectronNeutrinoRate;
DiffRate protonAntiElectronNeutrinoRate;
DiffRate protonMuonNeutrinoRate;
DiffRate protonAntiMuonNeutrinoRate;
DiffRate neutronAntiElectronNeutrinoRate;
DiffRate neutronMuonNeutrinoRate;
DiffRate neutronAntiMuonNeutrinoRate;
TotalRate elNeutTotalRate;
TotalRate muonNeutTotalRate;
TotalRate tauNeutTotalRate;
DiffRate elNeutScatRate;
DiffRate elNeutMuonNeutRate;
DiffRate elNeutTauNeutRate;
DiffRate elNeutElectronRate;
DiffRate elNeutPhotonRate;
DiffRate elNeutProtonRate;
DiffRate muonNeutScatRate;
DiffRate muonNeutElNeutRate;
DiffRate muonNeutTauNeutRate;
DiffRate muonNeutElectronRate;
DiffRate muonNeutPhotonRate;
DiffRate muonNeutProtonRate;
DiffRate tauNeutScatRate;
DiffRate tauNeutElNeutRate;
DiffRate tauNeutMuonNeutRate;
DiffRate tauNeutElectronRate;
DiffRate tauNeutPhotonRate;
DiffRate tauNeutProtonRate;
// rates from neutrino-neutrino interaction
dCVector synchrotronLoss; // sgdot
dCVector otherLoss; // tgdot
dCVector continuousLoss; // gdot
dCVector protonContinuousLoss; // pgdot
int loopCounter;
//-------- End of variable declaration --------
// numSmallSteps = 100;
convergeParameter = 1.e-8;
// -------- Redshift Estimation ---------------
// startingRedshift = pow(1. - 3.*H_0*1.e5*dist_observer/2./C, -2./3.) - 1.;
// This was the old analytic redshift computation.
dCVector RedshiftArray ;
dCVector DistanceArray ;
BuildRedshiftTable(aH0, aOmegaM, aOmegaLambda, &RedshiftArray, &DistanceArray) ;
startingRedshift = getRedshift(RedshiftArray, DistanceArray, dist_observer) ;
// printf("distance/Mpc: %15.6E\n", dist_observer);
// printf("particle type: %d\n", part);
// printf("injection energy/eV: %15.6E\n", InjEnergy);
B_bins = pB_field->dimension;
synchrotronSwitch = 1;
tauNeutrinoMassSwitch = 1;
ICSSwitch = 1;
PPSwitch = 1;
TPPSwitch = 1;
DPPSwitch = 1;
// PPPSwitch = 1;
PPPSwitch = 0;
NPPSwitch = 0;
// synchrotronSwitch = 0;
// tauNeutrinoMassSwitch = 0;
// ICSSwitch = 0;
// PPSwitch = 0;
// TPPSwitch = 0;
// DPPSwitch = 0;
// PPPSwitch = 1;
PPPSwitch = 0;
NPPSwitch = 0;
// printf("DINT modified!!\n");
#ifdef EXTRACT_PAIR_PROD_RATE
NPPSwitch = 1; // (allows to compute new pair prod rate)
#endif
// neutronDecaySwitch = 1;
neutronDecaySwitch = 0;
nucleonToSecondarySwitch = 0;
neutrinoNeutrinoSwitch = 1;
sourceTypeSwitch = 0;
minDistance = 0.;
brightPhaseExp = 0.;
//-------- Set up energy bins --------
New_dCVector(&deltaG, NUM_MAIN_BINS);
New_dCVector(&bgEnergy, NUM_BG_BINS);
New_dCVector(&bgEnergyWidth, NUM_BG_BINS);
New_dCVector(&bgPhotonDensity, NUM_BG_BINS);
// set energy bins
SetDeltaG(pEnergy, &deltaG);
SetEnergyBins(BG_MIN_ENERGY_EXP, &bgEnergy, &bgEnergyWidth);
NewSpectrum(&Q_0, NUM_MAIN_BINS);
NewSpectrum(&spectrumNew, NUM_MAIN_BINS);
NewSpectrum(&derivative, NUM_MAIN_BINS);
New_dCVector(&synchrotronLoss, NUM_MAIN_BINS);
New_dCVector(&otherLoss, NUM_MAIN_BINS);
New_dCVector(&continuousLoss, NUM_MAIN_BINS);
New_dCVector(&protonContinuousLoss, NUM_MAIN_BINS);
//---- Select injection model ----
// SetInjectionSpectrum(part, InjEnergy, HInjEnergy, deltaE_hadron,
// pEnergy, pEnergyWidth, &Q_0);
// SetInjectionSpectrum(part, pEnergy, pEnergyWidth, &Q_0, InjEnergy);
SetSpectrum(&Q_0, apInjectionSpectrum) ;
// No call anymore to SetInjectionSpectrum, which is not useful anymore.
totalEnergyInput = GetEnergy(&Q_0, pEnergy);
#ifdef DEBUG
DumpEnergy(&Q_0, pEnergy);
#endif
//-------- Create arrays --------
// NOTE: I first make them table size; they will be "clipped" after reading in tables
if (ICSSwitch == 1) {
NewRawTotalRate(&ICSTotalRate, EM_NUM_MAIN_BINS, NUM_BG_BINS);
NewRawDiffRate(&ICSPhotonRate, EM_NUM_MAIN_BINS, NUM_BG_BINS,
NUM_IP_ELEMENTS);
NewRawDiffRate(&ICSScatRate, EM_NUM_MAIN_BINS, NUM_BG_BINS,
NUM_IS_ELEMENTS);
}
if (PPSwitch == 1) {
NewRawTotalRate(&PPTotalRate, EM_NUM_MAIN_BINS, NUM_BG_BINS);
NewRawDiffRate(&PPDiffRate, EM_NUM_MAIN_BINS, NUM_BG_BINS,
NUM_PP_ELEMENTS);
}
if (TPPSwitch == 1) {
NewRawTotalRate(&TPPTotalRate, EM_NUM_MAIN_BINS, NUM_BG_BINS);
NewRawDiffRate(&TPPDiffRate, EM_NUM_MAIN_BINS, NUM_BG_BINS,
NUM_TPP_ELEMENTS);
}
if (DPPSwitch == 1)
NewRawTotalRate(&DPPRate, EM_NUM_MAIN_BINS, NUM_BG_BINS);
if (PPPSwitch == 1) {
NewRawTotalRate(&PPPProtonLossRate, NUC_NUM_MAIN_BINS, NUM_BG_BINS);
NewRawTotalRate(&PPPNeutronLossRate, NUC_NUM_MAIN_BINS, NUM_BG_BINS);
NewRawDiffRate(&PPPProtonScatRate, NUC_NUM_MAIN_BINS, NUM_BG_BINS,
NUM_PPP_PROTON_SCAT_ELEMENTS);
NewRawDiffRate(&PPPProtonNeutronRate, NUC_NUM_MAIN_BINS, NUM_BG_BINS,
NUM_PPP_PROTON_NEUTRON_ELEMENTS);
NewRawDiffRate(&PPPNeutronProtonRate, NUC_NUM_MAIN_BINS, NUM_BG_BINS,
NUM_PPP_PROTON_NEUTRON_ELEMENTS);
if (nucleonToSecondarySwitch == 1) {
NewRawDiffRate(&PPPProtonPhotonRate, NUC_NUM_MAIN_BINS,
NUM_BG_BINS, NUM_PPP_PROTON_PHOTON_ELEMENTS);
NewRawDiffRate(&PPPProtonElectronRate, NUC_NUM_MAIN_BINS,
NUM_BG_BINS, NUM_PPP_PROTON_ELECTRON_ELEMENTS);
NewRawDiffRate(&PPPProtonPositronRate, NUC_NUM_MAIN_BINS,
NUM_BG_BINS, NUM_PPP_PROTON_POSITRON_ELEMENTS);
NewRawDiffRate(&PPPNeutronElectronRate, NUC_NUM_MAIN_BINS,
NUM_BG_BINS, NUM_PPP_PROTON_POSITRON_ELEMENTS);
NewRawDiffRate(&PPPProtonElectronNeutrinoRate, NUC_NUM_MAIN_BINS,
NUM_BG_BINS, NUM_PPP_PROTON_ANTI_MUON_NEUTRINO_ELEMENTS);
NewRawDiffRate(&PPPProtonAntiElectronNeutrinoRate,
NUC_NUM_MAIN_BINS, NUM_BG_BINS,
NUM_PPP_PROTON_ANTI_ELECTRON_NEUTRINO_ELEMENTS);
NewRawDiffRate(&PPPProtonMuonNeutrinoRate, NUC_NUM_MAIN_BINS,
NUM_BG_BINS, NUM_PPP_PROTON_MUON_NEUTRINO_ELEMENTS);
NewRawDiffRate(&PPPProtonAntiMuonNeutrinoRate, NUC_NUM_MAIN_BINS,
NUM_BG_BINS, NUM_PPP_PROTON_ANTI_MUON_NEUTRINO_ELEMENTS);
NewRawDiffRate(&PPPNeutronAntiElectronNeutrinoRate,
NUC_NUM_MAIN_BINS, NUM_BG_BINS,
NUM_PPP_PROTON_ANTI_MUON_NEUTRINO_ELEMENTS);
NewRawDiffRate(&PPPNeutronMuonNeutrinoRate, NUC_NUM_MAIN_BINS,
NUM_BG_BINS, NUM_PPP_PROTON_ANTI_MUON_NEUTRINO_ELEMENTS);
NewRawDiffRate(&PPPNeutronAntiMuonNeutrinoRate, NUC_NUM_MAIN_BINS,
NUM_BG_BINS, NUM_PPP_PROTON_MUON_NEUTRINO_ELEMENTS);
}
}
if (NPPSwitch == 1) {
NewRawTotalRate(&NPPTotalRate, NUC_NUM_MAIN_BINS, NUM_BG_BINS);
if (nucleonToSecondarySwitch == 1)
NewRawDiffRate(&NPPDiffRate, NUC_NUM_MAIN_BINS, NUM_BG_BINS,
NUM_NPP_ELEMENTS);
}
// neutron decay does not fit the general category because it is not
// really an interaction (with background)
if (neutronDecaySwitch == 1) {
NewTotalRate(&neutronDecayRate, NUC_NUM_MAIN_BINS);
NewDiffRate(&neutronDecayProtonRate, NUC_NUM_MAIN_BINS);
if (nucleonToSecondarySwitch == 1)
NewDiffRate(&neutronDecayElectronRate, NUC_NUM_MAIN_BINS);
}
// neutrino-neutrino rates are already folded w/ neutrino background
if (neutrinoNeutrinoSwitch == 1) {
NewTotalRate(&NNElNeutTotalRate, NEUT_NUM_MAIN_BINS);
NewTotalRate(&NNMuonNeutTotalRate, NEUT_NUM_MAIN_BINS);
NewTotalRate(&NNTauNeutTotalRate, NEUT_NUM_MAIN_BINS);
NewDiffRate(&NNElNeutScatRate, NEUT_NUM_MAIN_BINS);
NewDiffRate(&NNElNeutMuonNeutRate, NEUT_NUM_MAIN_BINS);
NewDiffRate(&NNElNeutTauNeutRate, NEUT_NUM_MAIN_BINS);
NewDiffRate(&NNElNeutElectronRate, NEUT_NUM_MAIN_BINS);
NewDiffRate(&NNElNeutPhotonRate, NEUT_NUM_MAIN_BINS);
NewDiffRate(&NNElNeutProtonRate, NEUT_NUM_MAIN_BINS);
NewDiffRate(&NNMuonNeutScatRate, NEUT_NUM_MAIN_BINS);
NewDiffRate(&NNMuonNeutElNeutRate, NEUT_NUM_MAIN_BINS);
NewDiffRate(&NNMuonNeutTauNeutRate, NEUT_NUM_MAIN_BINS);
NewDiffRate(&NNMuonNeutElectronRate, NEUT_NUM_MAIN_BINS);
NewDiffRate(&NNMuonNeutPhotonRate, NEUT_NUM_MAIN_BINS);
NewDiffRate(&NNMuonNeutProtonRate, NEUT_NUM_MAIN_BINS);
NewDiffRate(&NNTauNeutScatRate, NEUT_NUM_MAIN_BINS);
NewDiffRate(&NNTauNeutElNeutRate, NEUT_NUM_MAIN_BINS);
NewDiffRate(&NNTauNeutMuonNeutRate, NEUT_NUM_MAIN_BINS);
NewDiffRate(&NNTauNeutElectronRate, NEUT_NUM_MAIN_BINS);
NewDiffRate(&NNTauNeutPhotonRate, NEUT_NUM_MAIN_BINS);
NewDiffRate(&NNTauNeutProtonRate, NEUT_NUM_MAIN_BINS);
}
//---- read in coefficient tables; clipping is done here if necessary ----
if (ICSSwitch == 1)
LoadICSTables(&ICSTotalRate, &ICSPhotonRate, &ICSScatRate,
NUM_MAIN_BINS, aDirTables);
if (PPSwitch == 1)
LoadPPTables(&PPTotalRate, &PPDiffRate, NUM_MAIN_BINS, aDirTables);
if (TPPSwitch == 1)
LoadTPPTables(&TPPTotalRate, &TPPDiffRate, NUM_MAIN_BINS, aDirTables);
if (DPPSwitch == 1)
LoadDPPTables(&DPPRate, NUM_MAIN_BINS, aDirTables);
if (PPPSwitch == 1) {
LoadPPPNucleonTables(&PPPProtonLossRate, &PPPNeutronLossRate,
&PPPProtonScatRate, &PPPProtonNeutronRate, &PPPNeutronProtonRate,
NUM_MAIN_BINS, aDirTables);
if (nucleonToSecondarySwitch == 1) {
LoadPPPEMTables(&PPPProtonPhotonRate, &PPPProtonElectronRate,
&PPPProtonPositronRate, &PPPNeutronElectronRate,
NUM_MAIN_BINS, aDirTables);
LoadPPPNeutrinoTables(&PPPProtonElectronNeutrinoRate,
&PPPProtonAntiElectronNeutrinoRate, &PPPProtonMuonNeutrinoRate,
&PPPProtonAntiMuonNeutrinoRate,
&PPPNeutronAntiElectronNeutrinoRate,
&PPPNeutronMuonNeutrinoRate, &PPPNeutronAntiMuonNeutrinoRate,
NUM_MAIN_BINS, aDirTables);
}
}
if (NPPSwitch == 1) {
LoadNPPNucleonTables(&NPPTotalRate, NUM_MAIN_BINS, aDirTables);
if (nucleonToSecondarySwitch == 1)
LoadNPPSecondaryTables(&NPPDiffRate, NUM_MAIN_BINS, aDirTables);
}
if (neutronDecaySwitch == 1) {
LoadNeutronDecayNucleonTables(&neutronDecayRate,
&neutronDecayProtonRate, NUM_MAIN_BINS, aDirTables);
if (nucleonToSecondarySwitch == 1)
LoadNeutronDecaySecondaryTables(&neutronDecayElectronRate,
NUM_MAIN_BINS, aDirTables);
}
if (neutrinoNeutrinoSwitch == 1)
LoadNeutrinoTables(tauNeutrinoMassSwitch, &NNElNeutTotalRate,
&NNMuonNeutTotalRate, &NNTauNeutTotalRate, &NNElNeutScatRate,
&NNElNeutMuonNeutRate, &NNElNeutTauNeutRate,
&NNElNeutElectronRate, &NNElNeutPhotonRate, &NNElNeutProtonRate,
&NNMuonNeutScatRate, &NNMuonNeutElNeutRate,
&NNMuonNeutTauNeutRate, &NNMuonNeutElectronRate,
&NNMuonNeutPhotonRate, &NNMuonNeutProtonRate, &NNTauNeutScatRate,
&NNTauNeutElNeutRate, &NNTauNeutMuonNeutRate,
&NNTauNeutElectronRate, &NNTauNeutPhotonRate,
&NNTauNeutProtonRate, NUM_MAIN_BINS, aDirTables);
#ifdef DEBUG
printf("Starting computations...\n\n");
#endif
//---- Initialize distance ----
distance = 0.; // distance variable: dist in FORTRAN
PrepareSpectra(sourceTypeSwitch, &Q_0, pSpectrum, &spectrumNew,
&derivative);
// NOTE: suspect derivative is never used???
// if (sourceTypeSwitch == 0) // single source
// DumpSpectrum(pEnergy, pEnergyWidth, &Q_0, "InitialSpectrumDump.dat");
ComputeTotalInitialContent(pEnergy, &Q_0, &initialPhotonEnergy,
&initialLeptonEnergy, &initialNucleonEnergy,
&initialNeutrinoEnergy, &initialTotalEnergy,
&initialPhotonNumber, &initialLeptonNumber,
&initialNucleonNumber, &initialNeutrinoNumber,
&initialTotalNumber);
//--------- START of actual computation --------
//---- initialize indices and parameters ----
iterationCounter = 1;
firstIndex = 0;
leftRedshift = startingRedshift;
deltaRedshift = 1. - (pEnergy->vector)[2]/(pEnergy->vector)[3];
lastIndex = 0;
propagatingDistance = 0.;
NewTotalRate(&leptonTotalRate, NUM_MAIN_BINS);
NewTotalRate(&photonTotalRate, NUM_MAIN_BINS);
NewTotalRate(&protonTotalRate, NUM_MAIN_BINS);
NewTotalRate(&neutronTotalRate, NUM_MAIN_BINS);
NewDiffRate(&leptonScatRate, NUM_MAIN_BINS);
NewDiffRate(&leptonExchRate, NUM_MAIN_BINS);
NewDiffRate(&leptonPhotonRate, NUM_MAIN_BINS);
NewDiffRate(&photonLeptonRate, NUM_MAIN_BINS);
NewDiffRate(&protonScatRate, NUM_MAIN_BINS);
NewDiffRate(&protonNeutronRate, NUM_MAIN_BINS);
NewDiffRate(&neutronProtonRate, NUM_MAIN_BINS);
NewDiffRate(&protonPhotonRate, NUM_MAIN_BINS);
NewDiffRate(&protonElectronRate, NUM_MAIN_BINS);
NewDiffRate(&protonPositronRate, NUM_MAIN_BINS);
NewDiffRate(&neutronElectronRate, NUM_MAIN_BINS);
NewDiffRate(&neutronPositronRate, NUM_MAIN_BINS);
NewDiffRate(&protonElectronNeutrinoRate, NUM_MAIN_BINS);
NewDiffRate(&protonAntiElectronNeutrinoRate, NUM_MAIN_BINS);
NewDiffRate(&protonMuonNeutrinoRate, NUM_MAIN_BINS);
NewDiffRate(&protonAntiMuonNeutrinoRate, NUM_MAIN_BINS);
NewDiffRate(&neutronAntiElectronNeutrinoRate, NUM_MAIN_BINS);
NewDiffRate(&neutronMuonNeutrinoRate, NUM_MAIN_BINS);
NewDiffRate(&neutronAntiMuonNeutrinoRate, NUM_MAIN_BINS);
NewTotalRate(&elNeutTotalRate, NUM_MAIN_BINS);
NewTotalRate(&muonNeutTotalRate, NUM_MAIN_BINS);
NewTotalRate(&tauNeutTotalRate, NUM_MAIN_BINS);
NewDiffRate(&elNeutScatRate, NUM_MAIN_BINS);
NewDiffRate(&elNeutMuonNeutRate, NUM_MAIN_BINS);
NewDiffRate(&elNeutTauNeutRate, NUM_MAIN_BINS);
NewDiffRate(&elNeutElectronRate, NUM_MAIN_BINS);
NewDiffRate(&elNeutPhotonRate, NUM_MAIN_BINS);
NewDiffRate(&elNeutProtonRate, NUM_MAIN_BINS);
NewDiffRate(&muonNeutElNeutRate, NUM_MAIN_BINS);
NewDiffRate(&muonNeutScatRate, NUM_MAIN_BINS);
NewDiffRate(&muonNeutTauNeutRate, NUM_MAIN_BINS);
NewDiffRate(&muonNeutElectronRate, NUM_MAIN_BINS);
NewDiffRate(&muonNeutPhotonRate, NUM_MAIN_BINS);
NewDiffRate(&muonNeutProtonRate, NUM_MAIN_BINS);
NewDiffRate(&tauNeutElNeutRate, NUM_MAIN_BINS);
NewDiffRate(&tauNeutMuonNeutRate, NUM_MAIN_BINS);
NewDiffRate(&tauNeutScatRate, NUM_MAIN_BINS);
NewDiffRate(&tauNeutElectronRate, NUM_MAIN_BINS);
NewDiffRate(&tauNeutPhotonRate, NUM_MAIN_BINS);
NewDiffRate(&tauNeutProtonRate, NUM_MAIN_BINS);
/* I created all folded rates because I didn't want to pass all the
switches to the subsequent functions, and these allocations are
not so expensive anyway */
//-------- This is where propagation takes place --------
do {
// this firstIndex & lastIndex pair is used to bin redshift finer
// near the end of propagation (z close to 0)
ComputeRedshifts(sourceTypeSwitch, leftRedshift, &deltaRedshift,
&rightRedshift, ¢ralRedshift, &lastIndex);
//---- compute various distance parameters ----
redshiftRatio = (1. + rightRedshift)/(1. + leftRedshift);
// tempCoefficient = pow(OMEGA_M*pow(1. + centralRedshift,3.)+
// OMEGA_LAMBDA, -1./2.)/(1.+centralRedshift);
// tempCoefficient = pow(1. + centralRedshift, -5./2.);
// distanceStep = (leftRedshift - rightRedshift)*tempCoefficient*C/
// (H_0*1.e5/1.e6/DISTANCE_UNIT);
// (cosmological parameters added July 2005)
leftDistance = getDistance(RedshiftArray,DistanceArray,leftRedshift) ;
rightDistance = getDistance(RedshiftArray,DistanceArray,rightRedshift) ;
distanceStep = leftDistance - rightDistance ;
distance += distanceStep;
// rightDistance = distance - distanceStep/2.;
// leftDistance = distance + distanceStep/2.;
// rightDistance = 2./3.*C/1.e5/H_0*(1. - pow(1. + rightRedshift, -1.5));
// leftDistance = 2./3.*C/1.e5/H_0*(1. - pow(1. + leftRedshift, -1.5));
evolutionFactor1 = pow((1. + centralRedshift)/(1. + startingRedshift),
brightPhaseExp+3.); // redshift evolution
numSmallSteps = (int)(ceil(distanceStep/DISTANCE_UNIT/DMAX));
smallDistanceStep = distanceStep/DISTANCE_UNIT/numSmallSteps;
x = 0.;
// printf("small stepsize: %15.6E\n", smallDistanceStep);
//---- compute the photon background at given redshift ----
LoadPhotonBackground(centralRedshift, &bgEnergy, &bgEnergyWidth,
&bgPhotonDensity, aIRFlag, aZmax_IR, aRadioFlag,
aH0, aOmegaM, aOmegaLambda);
// if (rightRedshift < 1.e-5)
// DumpBgSpectrum(&bgEnergy, &bgEnergyWidth, &bgPhotonDensity,"~/");
//---- initialize rates ----
InitializeLeptonCoefficients(&leptonTotalRate, &leptonScatRate,
&leptonExchRate, &leptonPhotonRate);
InitializePhotonCoefficients(&photonTotalRate, &photonLeptonRate);
InitializeNucleonCoefficients(&protonTotalRate, &neutronTotalRate,
&protonScatRate, &protonNeutronRate,
&neutronProtonRate, &protonPhotonRate,
&protonElectronRate, &protonPositronRate,
&neutronElectronRate, &neutronPositronRate,
&protonElectronNeutrinoRate,
&protonAntiElectronNeutrinoRate,
&protonMuonNeutrinoRate, &protonAntiMuonNeutrinoRate,
&neutronAntiElectronNeutrinoRate, &neutronMuonNeutrinoRate,
&neutronAntiMuonNeutrinoRate);
InitializeNeutrinoCoefficients(&elNeutTotalRate, &muonNeutTotalRate,
&tauNeutTotalRate, &elNeutScatRate, &elNeutMuonNeutRate,
&elNeutTauNeutRate, &elNeutElectronRate,
&elNeutPhotonRate, &elNeutProtonRate,
&muonNeutElNeutRate, &muonNeutScatRate,
&muonNeutTauNeutRate, &muonNeutElectronRate,
&muonNeutPhotonRate, &muonNeutProtonRate,
&tauNeutElNeutRate, &tauNeutMuonNeutRate,
&tauNeutScatRate, &tauNeutElectronRate,
&tauNeutPhotonRate, &tauNeutProtonRate);
Initialize_dCVector(&continuousLoss);
Initialize_dCVector(&otherLoss);
Initialize_dCVector(&protonContinuousLoss);
//---- fold interaction rates w/ photon background ----
if (ICSSwitch == 1)
FoldICS(&bgPhotonDensity, &ICSTotalRate, &ICSPhotonRate,
&ICSScatRate, &leptonTotalRate, &leptonPhotonRate,
&leptonScatRate);
if (TPPSwitch == 1)
FoldTPP(&bgPhotonDensity, pEnergy, &TPPTotalRate, &TPPDiffRate,
&leptonTotalRate, &leptonScatRate, &leptonExchRate,
&otherLoss);
if (PPSwitch == 1)
FoldPP(&bgPhotonDensity, &PPTotalRate, &PPDiffRate,
&photonTotalRate, &photonLeptonRate);
if (DPPSwitch == 1)
FoldDPP(&bgPhotonDensity, &DPPRate, &photonTotalRate,
&photonLeptonRate);
if (PPPSwitch == 1) {
FoldPPPNucleon(&bgPhotonDensity, &PPPProtonLossRate,
&PPPNeutronLossRate, &PPPProtonScatRate, &PPPProtonNeutronRate,
&PPPNeutronProtonRate, &protonTotalRate, &neutronTotalRate,
&protonScatRate, &protonNeutronRate, &neutronProtonRate);
if (nucleonToSecondarySwitch == 1)
FoldPPPSecondary(&bgPhotonDensity, &PPPProtonPhotonRate,
&PPPProtonElectronRate, &PPPProtonPositronRate,
&PPPNeutronElectronRate, &PPPProtonElectronNeutrinoRate,
&PPPProtonAntiElectronNeutrinoRate,
&PPPProtonMuonNeutrinoRate, &PPPProtonAntiMuonNeutrinoRate,
&PPPNeutronAntiElectronNeutrinoRate,
&PPPNeutronMuonNeutrinoRate,
&PPPNeutronAntiMuonNeutrinoRate, &protonPhotonRate,
&protonElectronRate, &protonPositronRate,
&neutronElectronRate, &neutronPositronRate,
&protonElectronNeutrinoRate,
&protonAntiElectronNeutrinoRate,
&protonMuonNeutrinoRate, &protonAntiMuonNeutrinoRate,
&neutronAntiElectronNeutrinoRate, &neutronMuonNeutrinoRate,
&neutronAntiMuonNeutrinoRate);
}
#ifdef EXTRACT_PHOTON_TOTAL_RATE
// Add - E.A. Dec. 2005
// Extract photon total energy loss rate
for (int i=0; i<pEnergy->dimension; i++) cout << (pEnergy->vector)[i] << " "
<< (photonTotalRate.totalRate)[i]
<< endl;
exit(0) ;
#endif
#ifdef EXTRACT_LEPTON_RATE
for (int i=0; i<pEnergy->dimension; i++) cout << (pEnergy->vector)[i] << " "
<< (leptonTotalRate.totalRate)[i]
<< endl;
exit(0) ;
#endif
if (NPPSwitch == 1) {
FoldNPPNucleon(&bgPhotonDensity, pEnergy, &NPPTotalRate,
&protonContinuousLoss);
#ifdef EXTRACT_PAIR_PROD_RATE
// Slight add - E.A. July 2005 .
// To extract the pair production tables of protons on photon backgrounds.
// (need to switch NPPSwitch!)
for (int i=0; i<pEnergy->dimension; i++) cout << (pEnergy->vector)[i] << " "
<< (protonContinuousLoss.vector)[i]
<< endl;
exit(0) ;
#endif
if (nucleonToSecondarySwitch == 1)
FoldNPPSecondary(&bgPhotonDensity, &NPPDiffRate,
&protonPositronRate, &protonElectronRate);
}
if (neutrinoNeutrinoSwitch == 1)
MapNeutRates(centralRedshift, lastIndex, tauNeutrinoMassSwitch,
&NNElNeutTotalRate, &NNMuonNeutTotalRate, &NNTauNeutTotalRate,
&NNElNeutScatRate, &NNElNeutMuonNeutRate,
&NNElNeutTauNeutRate, &NNElNeutElectronRate,
&NNElNeutPhotonRate, &NNElNeutProtonRate,
&NNMuonNeutElNeutRate, &NNMuonNeutScatRate,
&NNMuonNeutTauNeutRate, &NNMuonNeutElectronRate,
&NNMuonNeutPhotonRate, &NNMuonNeutProtonRate,
&NNTauNeutElNeutRate, &NNTauNeutMuonNeutRate,
&NNTauNeutScatRate, &NNTauNeutElectronRate,
&NNTauNeutPhotonRate, &NNTauNeutProtonRate, &elNeutTotalRate,
&muonNeutTotalRate, &tauNeutTotalRate, &elNeutScatRate,
&elNeutMuonNeutRate, &elNeutTauNeutRate, &elNeutElectronRate,
&elNeutPhotonRate, &elNeutProtonRate, &muonNeutElNeutRate,
&muonNeutScatRate, &muonNeutTauNeutRate, &muonNeutElectronRate,
&muonNeutPhotonRate, &muonNeutProtonRate, &tauNeutElNeutRate,
&tauNeutMuonNeutRate, &tauNeutScatRate, &tauNeutElectronRate,
&tauNeutPhotonRate, &tauNeutProtonRate);
//---- main iteration (convergence) block ----
for (loopCounter = 0; loopCounter < numSmallSteps; loopCounter++) {
if (synchrotronSwitch == 1) { // synchrotron == true (on)
NewDiffRate(&syncRate, NUM_MAIN_BINS);
B_bin = (int)((double)(B_bins)*(propagatingDistance+x)/1.e6/
dist_observer);
B_loc=(pB_field->vector)[B_bin];
InitializeSynchrotron(B_loc, pEnergy, pEnergyWidth,
&synchrotronLoss, &syncRate,
aDirTables);
}
//---- compute continuous energy loss for electrons ----
ComputeContinuousEnergyLoss(synchrotronSwitch, &synchrotronLoss,
&otherLoss, &continuousLoss);
evolutionFactor = evolutionFactor1;
if ((leftDistance - x/1.e6) < minDistance)
evolutionFactor = 0.;
if ((leftDistance - x/1.e6) < SOURCE_CLUSTER_DISTANCE)
evolutionFactor = SOURCE_CLUSTER_FACTOR*evolutionFactor1;
if ((leftDistance - x/1.e6) < CLUSTER_DISTANCE)
bkgFactor = CLUSTER_FACTOR;
else
bkgFactor = 1.;
AdvanceNucNeutStep(sourceTypeSwitch, PPPSwitch, NPPSwitch,
neutronDecaySwitch, nucleonToSecondarySwitch,
neutrinoNeutrinoSwitch, smallDistanceStep,
evolutionFactor, convergeParameter, bkgFactor, &Q_0,
&elNeutProtonRate,
&muonNeutProtonRate, &tauNeutProtonRate, &protonTotalRate,
&neutronTotalRate, &neutronDecayRate, &protonScatRate,
&protonNeutronRate, &neutronProtonRate,
&neutronDecayProtonRate, &protonMuonNeutrinoRate,
&neutronAntiMuonNeutrinoRate, &protonAntiMuonNeutrinoRate,
&neutronMuonNeutrinoRate, &protonElectronNeutrinoRate,
&neutronAntiElectronNeutrinoRate,
&protonAntiElectronNeutrinoRate, &neutronDecayElectronRate,
&elNeutTotalRate, &muonNeutTotalRate, &tauNeutTotalRate,
&elNeutScatRate, &elNeutMuonNeutRate, &elNeutTauNeutRate,
&muonNeutElNeutRate, &muonNeutScatRate, &muonNeutTauNeutRate,
&tauNeutElNeutRate, &tauNeutMuonNeutRate, &tauNeutScatRate,
&protonContinuousLoss, &deltaG, pSpectrum, &spectrumNew);
SetNucleonSpectrum(pSpectrum, &spectrumNew);
SetNeutrinoSpectrum(pSpectrum, &spectrumNew);
AdvanceEMStep(sourceTypeSwitch, PPSwitch, ICSSwitch,
TPPSwitch, DPPSwitch, synchrotronSwitch, PPPSwitch,
NPPSwitch, neutronDecaySwitch, nucleonToSecondarySwitch,
neutrinoNeutrinoSwitch, smallDistanceStep, evolutionFactor,
convergeParameter, bkgFactor, &Q_0, &photonLeptonRate,
&protonElectronRate, &neutronPositronRate,
&protonPositronRate, &neutronElectronRate,
&neutronDecayElectronRate, &elNeutElectronRate,
&muonNeutElectronRate, &tauNeutElectronRate,
&protonPhotonRate, &elNeutPhotonRate, &muonNeutPhotonRate,
&tauNeutPhotonRate, &leptonTotalRate, &leptonScatRate,
&leptonExchRate, &continuousLoss, &deltaG, &photonTotalRate,
&leptonPhotonRate, &syncRate, pSpectrum, &spectrumNew);
SetEMSpectrum(pSpectrum, &spectrumNew);
// update spectrum
if (aCutcascade_Magfield != 0 && B_loc != 0 ) {
// Estimate the effect of B field on the 1D approximation (added E.A. June 2006)
lEcFlag = 0 ;
lIndex = 0;
while (!lEcFlag) {
lEnergy = (pEnergy->vector)[lIndex] ;
// Time scales are computed in parsec
t_sync = 3.84e6/(lEnergy*B_loc*B_loc*ELECTRON_MASS) ;
t_larmor = (1.1e-21)*ELECTRON_MASS*lEnergy/(B_loc*aCutcascade_Magfield) ;
if (lEnergy <= 1.e15/ELECTRON_MASS) {
t_ics = 4.e2*1.e15/(ELECTRON_MASS*lEnergy) ;
} else if (lEnergy <= 1.e18/ELECTRON_MASS) {
t_ics = 4.e2*lEnergy*ELECTRON_MASS/1.e15 ;
} else if (lEnergy <= 1.e22/ELECTRON_MASS) {
t_ics = b_ics*pow(lEnergy*ELECTRON_MASS/1.e15,a_ics) ;
} else t_ics = 1.e8*lEnergy*ELECTRON_MASS/1.e22 ;
if (t_larmor >= t_sync || t_larmor >= t_ics) lEcFlag = 1 ;
// defines the "critical" energy : the e+/- spectrum is set to 0 for E<E_c
(pSpectrum->spectrum)[ELECTRON][lIndex]=0 ;
(pSpectrum->spectrum)[POSITRON][lIndex]=0 ;
lIndex++ ;
}
}
if (synchrotronSwitch == 1) // synchrotron == true (on)
DeleteDiffRate(&syncRate);
x += smallDistanceStep;
iterationCounter++;
}
propagatingDistance += x; // increment distance
//---- redshift bins down ----
RedshiftDown(lastIndex, redshiftRatio, pEnergy, pSpectrum,
&spectrumNew);
// printf("\nz = %g -> %g", leftRedshift, rightRedshift);
// printf("; d/Mpc = %g -> %g:\n", leftDistance, rightDistance);
// printf("%g, %g:\n", propagatingDistance, distance);
CheckEnergy(sourceTypeSwitch, brightPhaseExp, startingRedshift,
rightRedshift, pSpectrum, pEnergy, initialTotalEnergy);
//---- prepare for new step ----
leftRedshift = rightRedshift;
} while (lastIndex != 1);
//---- I am done with the rates ----
DeleteDiffRate(&leptonScatRate);
DeleteDiffRate(&leptonExchRate);
DeleteDiffRate(&leptonPhotonRate);
DeleteDiffRate(&photonLeptonRate);
DeleteDiffRate(&protonScatRate);
DeleteDiffRate(&protonNeutronRate);
DeleteDiffRate(&neutronProtonRate);
DeleteDiffRate(&protonPhotonRate);
DeleteDiffRate(&protonElectronRate);
DeleteDiffRate(&protonPositronRate);
DeleteDiffRate(&neutronElectronRate);
DeleteDiffRate(&neutronPositronRate);
DeleteDiffRate(&protonElectronNeutrinoRate);
DeleteDiffRate(&protonAntiElectronNeutrinoRate);
DeleteDiffRate(&protonMuonNeutrinoRate);
DeleteDiffRate(&protonAntiMuonNeutrinoRate);
DeleteDiffRate(&neutronAntiElectronNeutrinoRate);
DeleteDiffRate(&neutronMuonNeutrinoRate);
DeleteDiffRate(&neutronAntiMuonNeutrinoRate);
DeleteDiffRate(&elNeutScatRate);
DeleteDiffRate(&elNeutMuonNeutRate);
DeleteDiffRate(&elNeutTauNeutRate);
DeleteDiffRate(&elNeutElectronRate);
DeleteDiffRate(&elNeutPhotonRate);
DeleteDiffRate(&elNeutProtonRate);
DeleteDiffRate(&muonNeutElNeutRate);
DeleteDiffRate(&muonNeutScatRate);
DeleteDiffRate(&muonNeutTauNeutRate);
DeleteDiffRate(&muonNeutElectronRate);
DeleteDiffRate(&muonNeutPhotonRate);
DeleteDiffRate(&muonNeutProtonRate);
DeleteDiffRate(&tauNeutElNeutRate);
DeleteDiffRate(&tauNeutMuonNeutRate);
DeleteDiffRate(&tauNeutScatRate);
DeleteDiffRate(&tauNeutElectronRate);
DeleteDiffRate(&tauNeutPhotonRate);
DeleteDiffRate(&tauNeutProtonRate);
DeleteTotalRate(&leptonTotalRate);
DeleteTotalRate(&photonTotalRate);
DeleteTotalRate(&protonTotalRate);
DeleteTotalRate(&neutronTotalRate);
DeleteTotalRate(&elNeutTotalRate);
DeleteTotalRate(&muonNeutTotalRate);
DeleteTotalRate(&tauNeutTotalRate);
if (ICSSwitch == 1) {
DeleteRawDiffRate(&ICSPhotonRate);
DeleteRawDiffRate(&ICSScatRate);
DeleteRawTotalRate(&ICSTotalRate);
}
if (PPSwitch == 1) {
DeleteRawDiffRate(&PPDiffRate);
DeleteRawTotalRate(&PPTotalRate);
}
if (TPPSwitch == 1) {
DeleteRawDiffRate(&TPPDiffRate);
DeleteRawTotalRate(&TPPTotalRate);
}
if (PPPSwitch == 1) {
DeleteRawDiffRate(&PPPProtonScatRate);
DeleteRawDiffRate(&PPPProtonNeutronRate);
DeleteRawDiffRate(&PPPNeutronProtonRate);
DeleteRawTotalRate(&PPPProtonLossRate);
DeleteRawTotalRate(&PPPNeutronLossRate);
if (nucleonToSecondarySwitch == 1) {
DeleteRawDiffRate(&PPPProtonPhotonRate);
DeleteRawDiffRate(&PPPProtonElectronRate);
DeleteRawDiffRate(&PPPProtonPositronRate);
DeleteRawDiffRate(&PPPNeutronElectronRate);
DeleteRawDiffRate(&PPPProtonElectronNeutrinoRate);
DeleteRawDiffRate(&PPPProtonAntiElectronNeutrinoRate);
DeleteRawDiffRate(&PPPProtonMuonNeutrinoRate);
DeleteRawDiffRate(&PPPProtonAntiMuonNeutrinoRate);
DeleteRawDiffRate(&PPPNeutronAntiElectronNeutrinoRate);
DeleteRawDiffRate(&PPPNeutronMuonNeutrinoRate);
DeleteRawDiffRate(&PPPNeutronAntiMuonNeutrinoRate);
}
}
if (NPPSwitch == 1) {
if (nucleonToSecondarySwitch == 1)
DeleteRawDiffRate(&NPPDiffRate);
DeleteRawTotalRate(&NPPTotalRate);
}
if (DPPSwitch == 1)
DeleteRawTotalRate(&DPPRate);
if (neutronDecaySwitch == 1) {
if (nucleonToSecondarySwitch == 1)
DeleteDiffRate(&neutronDecayElectronRate);
DeleteDiffRate(&neutronDecayProtonRate);
DeleteTotalRate(&neutronDecayRate);
}
if (neutrinoNeutrinoSwitch == 1) {
DeleteDiffRate(&NNElNeutScatRate);
DeleteDiffRate(&NNElNeutMuonNeutRate);
DeleteDiffRate(&NNElNeutTauNeutRate);
DeleteDiffRate(&NNElNeutElectronRate);
DeleteDiffRate(&NNElNeutPhotonRate);
DeleteDiffRate(&NNElNeutProtonRate);
DeleteDiffRate(&NNMuonNeutElNeutRate);
DeleteDiffRate(&NNMuonNeutScatRate);
DeleteDiffRate(&NNMuonNeutTauNeutRate);
DeleteDiffRate(&NNMuonNeutElectronRate);
DeleteDiffRate(&NNMuonNeutPhotonRate);
DeleteDiffRate(&NNMuonNeutProtonRate);
DeleteDiffRate(&NNTauNeutElNeutRate);
DeleteDiffRate(&NNTauNeutMuonNeutRate);
DeleteDiffRate(&NNTauNeutScatRate);
DeleteDiffRate(&NNTauNeutElectronRate);
DeleteDiffRate(&NNTauNeutPhotonRate);
DeleteDiffRate(&NNTauNeutProtonRate);
DeleteTotalRate(&NNElNeutTotalRate);
DeleteTotalRate(&NNMuonNeutTotalRate);
DeleteTotalRate(&NNTauNeutTotalRate);
}
// FinalPrintOutToTheScreen(distance, startingRedshift, propagatingDistance);
DeleteSpectrum(&Q_0);
DeleteSpectrum(&spectrumNew);
DeleteSpectrum(&derivative);
Delete_dCVector(&synchrotronLoss);
Delete_dCVector(&continuousLoss);
Delete_dCVector(&otherLoss);
Delete_dCVector(&protonContinuousLoss);
Delete_dCVector(&deltaG);
Delete_dCVector(&bgEnergy);
Delete_dCVector(&bgEnergyWidth);
Delete_dCVector(&bgPhotonDensity);
Delete_dCVector(&RedshiftArray) ;
Delete_dCVector(&DistanceArray) ;
}
PhotonDINT1DImpl() {
// Initialize the energy grids for dint
New_dCVector(&energyGrid, NUM_MAIN_BINS);
New_dCVector(&energyWidth, NUM_MAIN_BINS);
SetEnergyBins(MIN_ENERGY_EXP, &energyGrid, &energyWidth);
}
