bool UnitTests::WeightedDataMatrixMothur()
{
std::vector< std::vector<double> > dissMatrix;
// weighted Bray-Curtis
DiversityCalculator BC("../unit-tests/DataMatrixMothur.env", "", "Bray-Curtis", 1000, true, false, false, false, false);
BC.Dissimilarity("../unit-tests/temp", "UPGMA");
ReadDissMatrix("../unit-tests/temp.diss", dissMatrix);
if(!Compare(dissMatrix[1][0], 0.8))
return false;
if(!Compare(dissMatrix[2][0], 0.6))
return false;
if(!Compare(dissMatrix[2][1], 0.8))
return false;
// weighted Canberra
DiversityCalculator Canberra("../unit-tests/DataMatrixMothur.env", "", "Canberra", 1000, true, false, false, false, false);
Canberra.Dissimilarity("../unit-tests/temp", "UPGMA");
ReadDissMatrix("../unit-tests/temp.diss", dissMatrix);
if(!Compare(dissMatrix[1][0], 6.35152))
return false;
if(!Compare(dissMatrix[2][0], 8.11111))
return false;
if(!Compare(dissMatrix[2][1], 5.92063))
return false;
// weighted Gower
DiversityCalculator Gower("../unit-tests/DataMatrixMothur.env", "", "Gower", 1000, true, false, false, false, false);
Gower.Dissimilarity("../unit-tests/temp", "UPGMA");
ReadDissMatrix("../unit-tests/temp.diss", dissMatrix);
if(!Compare(dissMatrix[1][0], 6.58333))
return false;
if(!Compare(dissMatrix[2][0], 7.88889))
return false;
if(!Compare(dissMatrix[2][1], 5.52778))
return false;
// weighted Hellinger
DiversityCalculator Hellinger("../unit-tests/DataMatrixMothur.env", "", "Hellinger", 1000, true, false, false, false, false);
Hellinger.Dissimilarity("../unit-tests/temp", "UPGMA");
ReadDissMatrix("../unit-tests/temp.diss", dissMatrix);
if(!Compare(dissMatrix[1][0], 1.13904))
return false;
if(!Compare(dissMatrix[2][0], 1.05146))
return false;
if(!Compare(dissMatrix[2][1], 1.17079))
return false;
// weighted Manhattan
DiversityCalculator Manhattan("../unit-tests/DataMatrixMothur.env", "", "Manhattan", 1000, true, false, false, false, false);
Manhattan.Dissimilarity("../unit-tests/temp", "UPGMA");
ReadDissMatrix("../unit-tests/temp.diss", dissMatrix);
if(!Compare(dissMatrix[1][0], 1.6))
return false;
if(!Compare(dissMatrix[2][0], 1.2))
return false;
if(!Compare(dissMatrix[2][1], 1.6))
return false;
// weighted Morisita-Horn
DiversityCalculator MH("../unit-tests/DataMatrixMothur.env", "", "Morisita-Horn", 1000, true, false, false, false, false);
MH.Dissimilarity("../unit-tests/temp", "UPGMA");
ReadDissMatrix("../unit-tests/temp.diss", dissMatrix);
if(!Compare(dissMatrix[1][0], 0.873239))
return false;
if(!Compare(dissMatrix[2][0], 0.333333))
return false;
if(!Compare(dissMatrix[2][1], 0.859155))
return false;
// weighted Soergel
DiversityCalculator Soergel("../unit-tests/DataMatrixMothur.env", "", "Soergel", 1000, true, false, false, false, false);
Soergel.Dissimilarity("../unit-tests/temp", "UPGMA");
ReadDissMatrix("../unit-tests/temp.diss", dissMatrix);
if(!Compare(dissMatrix[1][0], 0.88888901))
return false;
if(!Compare(dissMatrix[2][0], 0.75))
return false;
if(!Compare(dissMatrix[2][1], 0.88888901))
return false;
// weighted species profile
/*
DiversityCalculator SP("../unit-tests/DataMatrixMothur.env", "", "Species profile", 1000, true, false, false, false, false);
SP.Dissimilarity("../unit-tests/temp.diss");
ReadDissMatrix("../unit-tests/temp.diss", dissMatrix);
if(!Compare(dissMatrix[1][0], 0.78740102))
return false;
if(!Compare(dissMatrix[2][0], 0.44721401))
return false;
if(!Compare(dissMatrix[2][1], 0.78102499))
return false;
*/
// weighted Chi-squared
// Note: EBD uses a slightly different form of the Chi-squared measure as suggested in Numerical Ecology by Legendre adn Legendre
// Nonetheless, it is easy to verify this using mothur. Simply divide by sqrt(N), N is the total number of sequences.
DiversityCalculator ChiSquared("../unit-tests/DataMatrixMothur.env", "", "Chi-squared", 1000, true, false, false, false, false);
ChiSquared.Dissimilarity("../unit-tests/temp", "UPGMA");
ReadDissMatrix("../unit-tests/temp.diss", dissMatrix);
if(!Compare(dissMatrix[1][0], 1.0973200))
return false;
if(!Compare(dissMatrix[2][0], 0.96513098))
return false;
if(!Compare(dissMatrix[2][1], 1.1147900))
return false;
// weighted Euclidean
DiversityCalculator Euclidean("../unit-tests/DataMatrixMothur.env", "", "Euclidean", 1000, true, false, false, false, false);
Euclidean.Dissimilarity("../unit-tests/temp", "UPGMA");
ReadDissMatrix("../unit-tests/temp.diss", dissMatrix);
if(!Compare(dissMatrix[1][0], 0.78740102))
return false;
if(!Compare(dissMatrix[2][0], 0.44721401))
return false;
if(!Compare(dissMatrix[2][1], 0.78102499))
return false;
// weighted Kulczynski
DiversityCalculator Kulczynski("../unit-tests/DataMatrixMothur.env", "", "Kulczynski", 1000, true, false, false, false, false);
Kulczynski.Dissimilarity("../unit-tests/temp", "UPGMA");
ReadDissMatrix("../unit-tests/temp.diss", dissMatrix);
if(!Compare(dissMatrix[1][0], 0.8))
return false;
if(!Compare(dissMatrix[2][0], 0.6))
return false;
if(!Compare(dissMatrix[2][1], 0.8))
return false;
// weighted Pearson
DiversityCalculator uPearson("../unit-tests/DataMatrixMothur.env", "", "Pearson", 1000, true, false, false, false, false);
uPearson.Dissimilarity("../unit-tests/temp", "UPGMA");
ReadDissMatrix("../unit-tests/temp.diss", dissMatrix);
if(!Compare(dissMatrix[1][0], 1.22089))
return false;
if(!Compare(dissMatrix[2][0], 0.5))
return false;
if(!Compare(dissMatrix[2][1], 1.2008))
return false;
// weighted Yue-Clayton
DiversityCalculator YC("../unit-tests/DataMatrixMothur.env", "", "YueClayton", 1000, true, false, false, false, false);
YC.Dissimilarity("../unit-tests/temp", "UPGMA");
ReadDissMatrix("../unit-tests/temp.diss", dissMatrix);
if(!Compare(dissMatrix[1][0], 0.93233103))
return false;
if(!Compare(dissMatrix[2][0], 0.5))
return false;
if(!Compare(dissMatrix[2][1], 0.92424202))
return false;
return true;
}
int tester()
{
//description
std::vector<std::string> neutrals;
std::vector<std::string> ions;
neutrals.push_back("N2");
neutrals.push_back("CH4");
neutrals.push_back("C2H");
//ionic system contains neutral system
ions = neutrals;
ions.push_back("N2+");
Scalar MN(14.008L), MC(12.011), MH(1.008L);
Scalar MN2 = 2.L*MN , MCH4 = MC + 4.L*MH, MC2H = 2.L * MC + MH;
std::vector<Scalar> Mm;
Mm.push_back(MN2);
Mm.push_back(MCH4);
Mm.push_back(MC2H);
//densities
std::vector<Scalar> molar_frac;
molar_frac.push_back(0.95999L);
molar_frac.push_back(0.04000L);
molar_frac.push_back(0.00001L);
molar_frac.push_back(0.L);
Scalar dens_tot(1e12L);
//hard sphere radius
std::vector<Scalar> hard_sphere_radius;
hard_sphere_radius.push_back(2.0675e-8L * 1e-2L); //N2 in cm -> m
hard_sphere_radius.push_back(2.3482e-8L * 1e-2L); //CH4 in cm -> m
hard_sphere_radius.push_back(0.L); //C2H
//zenith angle
//not necessary
//photon flux
//not necessary
////cross-section
//not necessary
//altitudes
Scalar zmin(600.),zmax(1400.),zstep(10.);
//binary diffusion
Scalar bCN1(1.04e-5 * 1e-4),bCN2(1.76); //cm2 -> m2
Planet::DiffusionType CN_model(Planet::DiffusionType::Wakeham);
Scalar bCC1(5.73e16 * 1e-4),bCC2(0.5); //cm2 -> m2
Planet::DiffusionType CC_model(Planet::DiffusionType::Wilson);
Scalar bNN1(0.1783 * 1e-4),bNN2(1.81); //cm2 -> m2
Planet::DiffusionType NN_model(Planet::DiffusionType::Massman);
/************************
* first level
************************/
//altitude
Planet::Altitude<Scalar,std::vector<Scalar> > altitude(zmin,zmax,zstep);
//neutrals
Antioch::ChemicalMixture<Scalar> neutral_species(neutrals);
//ions
Antioch::ChemicalMixture<Scalar> ionic_species(ions);
//chapman
//not needed
//binary diffusion
Planet::BinaryDiffusion<Scalar> N2N2( Antioch::Species::N2, Antioch::Species::N2 , bNN1, bNN2, NN_model);
Planet::BinaryDiffusion<Scalar> N2CH4( Antioch::Species::N2, Antioch::Species::CH4, bCN1, bCN2, CN_model);
Planet::BinaryDiffusion<Scalar> CH4CH4( Antioch::Species::CH4, Antioch::Species::CH4, bCC1, bCC2, CC_model);
Planet::BinaryDiffusion<Scalar> N2C2H( Antioch::Species::N2, Antioch::Species::C2H);
Planet::BinaryDiffusion<Scalar> CH4C2H( Antioch::Species::CH4, Antioch::Species::C2H);
std::vector<std::vector<Planet::BinaryDiffusion<Scalar> > > bin_diff_coeff;
bin_diff_coeff.resize(2);
bin_diff_coeff[0].push_back(N2N2);
bin_diff_coeff[0].push_back(N2CH4);
bin_diff_coeff[0].push_back(N2C2H);
bin_diff_coeff[1].push_back(N2CH4);
bin_diff_coeff[1].push_back(CH4CH4);
bin_diff_coeff[1].push_back(CH4C2H);
/************************
* second level
************************/
//temperature
std::vector<Scalar> T0,Tz;
read_temperature<Scalar>(T0,Tz,"input/temperature.dat");
std::vector<Scalar> neutral_temperature;
linear_interpolation(T0,Tz,altitude.altitudes(),neutral_temperature);
Planet::AtmosphericTemperature<Scalar, std::vector<Scalar> > temperature(neutral_temperature, neutral_temperature, altitude);
//photon opacity
//not needed
//reaction sets
//not needed
/************************
* third level
************************/
//atmospheric mixture
Planet::AtmosphericMixture<Scalar,std::vector<Scalar>, std::vector<std::vector<Scalar> > > composition(neutral_species, ionic_species, altitude, temperature);
composition.init_composition(molar_frac,dens_tot);
composition.set_hard_sphere_radius(hard_sphere_radius);
composition.initialize();
//kinetics evaluators
//not needed
/************************
* fourth level
************************/
//photon evaluator
//not needed
//molecular diffusion
Planet::MolecularDiffusionEvaluator<Scalar,std::vector<Scalar>, std::vector<std::vector<Scalar> > > molecular_diffusion(bin_diff_coeff,
composition,
altitude,
temperature);
molecular_diffusion.make_molecular_diffusion();
//eddy diffusion
//not needed
/************************
* checks
************************/
molar_frac.pop_back();//get the ion outta here
Scalar Matm(0.L);
for(unsigned int s = 0; s < molar_frac.size(); s++)
{
Matm += molar_frac[s] * composition.neutral_composition().M(s);
}
Matm *= 1e-3L; //to kg
std::vector<std::vector<Scalar> > densities;
calculate_densities(densities, dens_tot, molar_frac, zmin,zmax,zstep, temperature.neutral_temperature(), Mm);
//N2, CH4, C2H
std::vector<std::vector<Scalar> > Dij;
Dij.resize(2);
Dij[0].resize(3,0.L);
Dij[1].resize(3,0.L);
int return_flag(0);
for(unsigned int iz = 0; iz < altitude.altitudes().size(); iz++)
{
Scalar P = pressure(composition.total_density()[iz],temperature.neutral_temperature()[iz]);
Scalar T = temperature.neutral_temperature()[iz];
Dij[0][0] = binary_coefficient(T,P,bNN1,bNN2); //N2 N2
Dij[1][1] = binary_coefficient(T,P,bCC1 * Antioch::ant_pow(Planet::Constants::Convention::T_standard<Scalar>(),bCC2 + Scalar(1.L))
* Planet::Constants::Universal::kb<Scalar>()
/ Planet::Constants::Convention::P_normal<Scalar>(),bCC2 + Scalar(1.L)); //CH4 CH4
Dij[0][1] = binary_coefficient(T,P,bCN1 * Antioch::ant_pow(Planet::Constants::Convention::T_standard<Scalar>(),bCN2),bCN2); //N2 CH4
Dij[0][2] = binary_coefficient(Dij[0][0],Mm[0],Mm[2]); //N2 C2H
Dij[1][2] = binary_coefficient(Dij[1][1],Mm[1],Mm[2]); //CH4 C2H
Dij[1][0] = Dij[0][1]; //CH4 N2
for(unsigned int s = 0; s < molar_frac.size(); s++)
{
Scalar tmp(0.L);
Scalar M_diff(0.L);
for(unsigned int medium = 0; medium < 2; medium++)
{
if(s == medium)continue;
tmp += densities[medium][iz]/Dij[medium][s];
}
Scalar Ds = (barometry(zmin,altitude.altitudes()[iz],neutral_temperature[iz],Matm,dens_tot) - densities[s][iz]) / tmp;
for(unsigned int j = 0; j < molar_frac.size(); j++)
{
if(s == j)continue;
M_diff += composition.total_density()[iz] * composition.neutral_molar_fraction()[j][iz] * composition.neutral_composition().M(j);
}
M_diff /= Scalar(molar_frac.size() - 1);
Scalar Dtilde = Ds / (Scalar(1.L) - composition.neutral_molar_fraction()[s][iz] * (Scalar(1.L) - composition.neutral_composition().M(s)/M_diff));
return_flag = return_flag ||
check_test(Dtilde,molecular_diffusion.Dtilde()[s][iz],"D tilde of species at altitude");
}
return_flag = return_flag ||
check_test(Dij[0][0],molecular_diffusion.binary_coefficient(0,0,T,P),"binary molecular coefficient N2 N2 at altitude") ||
check_test(Dij[0][1],molecular_diffusion.binary_coefficient(0,1,T,P),"binary molecular coefficient N2 CH4 at altitude") ||
check_test(Dij[0][2],molecular_diffusion.binary_coefficient(0,2,T,P),"binary molecular coefficient N2 C2H at altitude") ||
check_test(Dij[1][1],molecular_diffusion.binary_coefficient(1,1,T,P),"binary molecular coefficient CH4 CH4 at altitude") ||
check_test(Dij[1][2],molecular_diffusion.binary_coefficient(1,2,T,P),"binary molecular coefficient CH4 C2H at altitude");
}
return return_flag;
}
int test()
{
std::vector<std::string> neutrals;
std::vector<std::string> ions;
neutrals.push_back("N2");
neutrals.push_back("CH4");
ions.push_back("N2+");
ions.push_back("e");
Scalar chi(100.L);
std::vector<Scalar> lambda_ref,phy1AU,phy_on_top;
std::ifstream flux_1AU("./input/hv_SSI.dat");
std::string line;
getline(flux_1AU,line);
while(!flux_1AU.eof())
{
Scalar wv,ir,dirr;
flux_1AU >> wv >> ir >> dirr;
if(!lambda_ref.empty() && wv == lambda_ref.back())continue;
lambda_ref.push_back(wv);//nm
phy1AU.push_back(ir);//W/m2/nm
phy_on_top.push_back(ir/std::pow(Planet::Constants::Saturn::d_Sun<Scalar>(),2));
}
flux_1AU.close();
Planet::Chapman<Scalar> chapman(chi);
Planet::PhotonFlux<Scalar,std::vector<Scalar>, std::vector<std::vector<Scalar> > > photon(chapman);
photon.set_photon_flux_top_atmosphere(lambda_ref,phy1AU,Planet::Constants::Saturn::d_Sun<Scalar>());
std::vector<Scalar> molar_frac = {0.96,0.04,0.,0.};
Scalar dens_tot(1e12);
Planet::Atmosphere<Scalar, std::vector<Scalar>, std::vector<std::vector<Scalar> > > atm(neutrals,ions,photon);
atm.make_altitude_grid(600.,1400.,10.);
std::ifstream temp("input/temperature.dat");
std::vector<Scalar> T0,Tz;
getline(temp,line);
while(!temp.eof())
{
Scalar t,tz,dt,dtz;
temp >> t >> tz >> dt >> dtz;
T0.push_back(t);
Tz.push_back(tz);
}
temp.close();
atm.set_temperature(T0,Tz);
std::vector<Scalar> T = atm.temperature_top_to_bottom();
std::vector<std::vector<Scalar> > MatrixTotalDensity;
std::vector<Scalar> tot_dens = atm.total_density_top_to_bottom();
std::vector<Scalar> lambda_N2,sigma_N2;
std::vector<std::vector<Scalar> > sigma_rate_N2;
sigma_rate_N2.resize(3);
std::ifstream sig_N2("./input/N2_hv_cross-sections.dat");
std::ifstream sig_CH4("./input/CH4_hv_cross-sections.dat");
getline(sig_N2,line);
getline(sig_CH4,line);
while(!sig_N2.eof())
{
Scalar wv,sigt,sig1,sig2,sig3;
sig_N2 >> wv >> sigt >> sig1 >> sig2 >> sig3;
lambda_N2.push_back(wv/10.);//A -> nm
sigma_N2.push_back(sigt*10.);//cm-2/A -> cm-2/nm
sigma_rate_N2[0].push_back(sig1*10.);
sigma_rate_N2[1].push_back(sig2*10.);
sigma_rate_N2[2].push_back(sig3*10.);
}
sig_N2.close();
atm.add_photoabsorption("N2",lambda_N2,sigma_N2);
std::vector<Scalar> lambda_CH4,sigma_CH4;
std::vector<std::vector<Scalar> > sigma_rate_CH4;
sigma_rate_CH4.resize(9);
while(!sig_CH4.eof())
{
Scalar wv,sigt,sig1,sig2,sig3,sig4,sig5,sig6,sig7,sig8,sig9;
sig_CH4 >> wv >> sigt >> sig1 >> sig2 >> sig3 >> sig4 >> sig5 >> sig6 >> sig7 >> sig8 >> sig9;
lambda_CH4.push_back(wv/10.);//A -> nm
sigma_CH4.push_back(sigt*10.);//cm-2/A -> cm-2/nm
sigma_rate_CH4[0].push_back(sig1*10.);
sigma_rate_CH4[1].push_back(sig2*10.);
sigma_rate_CH4[2].push_back(sig3*10.);
sigma_rate_CH4[3].push_back(sig4*10.);
sigma_rate_CH4[4].push_back(sig5*10.);
sigma_rate_CH4[5].push_back(sig6*10.);
sigma_rate_CH4[6].push_back(sig7*10.);
sigma_rate_CH4[7].push_back(sig8*10.);
sigma_rate_CH4[8].push_back(sig9*10.);
}
sig_CH4.close();
atm.add_photoabsorption("CH4",lambda_CH4,sigma_CH4);
atm.init_composition(molar_frac,dens_tot);
int return_flag(0);
//Phy at top
std::vector<Scalar> phy_top;
phy_top.resize(lambda_ref.size(),0.L);
for(unsigned int il = 0; il < lambda_ref.size(); il++)
{
phy_top[il] = phy1AU[il]/(Planet::Constants::Saturn::d_Sun<Scalar>() * Planet::Constants::Saturn::d_Sun<Scalar>());
if(check_test(phy_top[il],photon.phy_at_top()[il],"Photon flux at top"))return_flag = 1;
}
std::ofstream out("phy_z.dat");
std::ofstream out_the("phy_z_the.dat");
out_the << "z N_N N+_N N2+ sCH2_H2 CH3_H CH2_H_H CH4+ CH3+_H CH2+_H2 CH+_H2_H H+_CH3 CH_H2_H" << std::endl;
std::vector<Scalar> lamb = atm.hv_flux().lambda();
std::vector<Scalar> sum_over_neutral;
sum_over_neutral.resize(2,0.L);
std::vector<Scalar> tau_theo;
std::vector<Scalar> rate_N2,rate_CH4;
rate_N2.resize(3);
rate_CH4.resize(9);
Scalar MN(14.008L), MC(12.011), MH(1.008L);
Scalar MN2 = 2.L*MN , MCH4 = MC + 4.L*MH;
unsigned int ialt(0);
for(Scalar z = 1400.; z >= 600.; z -= 10.)
{
Scalar M_the = molar_frac[0] * MN2 + molar_frac[1] * MCH4;
Scalar n_tot_the = dens_tot * std::exp(-(z - 600.) /
( (z + Planet::Constants::Titan::radius<Scalar>()) *
(600. + Planet::Constants::Titan::radius<Scalar>()) * 1e3L * //to m
( (Planet::Constants::Universal::kb<Scalar>() * Antioch::Constants::Avogadro<Scalar>() * T[ialt]) /
(Planet::Constants::Universal::G<Scalar>() * Planet::Constants::Titan::mass<Scalar>() * M_the * 1e-3L) //to kg/mol
)
));
tau_theo.clear();
tau_theo.resize(lambda_ref.size(),0.L);
for(unsigned int i = 0; i < 2; i++)
{
sum_over_neutral[i] += molar_frac[i] * n_tot_the;
for(unsigned int il = 0; il < lambda_ref.size(); il++)
{
tau_theo[il] += sum_over_neutral[i] * atm.photon_sigma(i).y_on_custom()[il]; //filtering
}
}
std::vector<Scalar> tau_cal = photon.tau(z,sum_over_neutral);
for(unsigned int il = 0; il < lambda_ref.size(); il++)
{
tau_theo[il] *= chapman.chapman(atm.a(z));
if(check_test(tau_theo[il],tau_cal[il],"tau at altitude z"))return_flag = 1;
}
for(unsigned int ir = 0; ir < 3; ir++)
{
rate_N2[ir] = 0.L;
for(unsigned int il = 0; il < lamb.size(); il++)
{
rate_N2[ir] += sigma_rate_N2[ir][il] * phy_on_top[il] * std::exp(-tau_theo[il]);
}
}
for(unsigned int ir = 0; ir < 9; ir++)
{
rate_CH4[ir] = 0.L;
for(unsigned int il = 0; il < lamb.size(); il++)
{
rate_CH4[ir] += sigma_rate_CH4[ir][il] * phy_on_top[il] * std::exp(-tau_theo[il]);
}
}
std::vector<Scalar> phy_flux = atm.hv_flux().phy(z);
for(unsigned int il = 0; il < phy_flux.size(); il++)
{
if(check_test(phy_on_top[il] * std::exp(-tau_theo[il]),phy_flux[il],"phy at altitude z and lambda"))return_flag = 1;
out << lamb[il] << " " << phy_flux[il] << std::endl;
}
out_the << z << " ";
for(unsigned int ir = 0; ir < 3; ir++)
{
out_the << rate_N2[ir] << " ";
}
for(unsigned int ir = 0; ir < 9; ir++)
{
out_the << rate_CH4[ir] << " ";
}
out_the << std::endl;
out << std::endl;
ialt++;
}
out.close();
out_the.close();
return return_flag;
}
