bool Level::LoadLevelInfo(const char *pszLevelName, IniReader *piniLoaded)
{
IniReader *pini;
if (piniLoaded == NULL) {
pini = LoadIniFile(gpakr, pszLevelName);
if (pini == NULL) {
Assert(false);
return false;
}
} else {
pini = piniLoaded;
}
// Get level version
if (pini->GetPropertyValue("General", "Version", "%d", &m_nVersion) == 0)
m_nVersion = 0;
// Get revision #
if (pini->GetPropertyValue("General", "Revision", "%d", &m_dwRevision) == 0)
m_dwRevision = 0;
// Can't run if the level version is newer than what the game supports
bool fSuccess = true;
if (m_nVersion > knVersionLevelSupported) {
fSuccess = false;
HtMessageBox(kfMbWhiteBorder, "Error", "Newer version of Hostile Takeover required to run this mission.");
} else {
// Load General level data
if (!pini->GetPropertyValue("General", "Title", m_szTitle, sizeof(m_szTitle)))
strcpy(m_szTitle, "<untitled>");
m_nPlayersMin = m_nPlayersMax = 0;
pini->GetPropertyValue("General", "MinPlayers", "%d", &m_nPlayersMin);
pini->GetPropertyValue("General", "MaxPlayers", "%d", &m_nPlayersMax);
// Normalize
if (pszLevelName[0] == 'm' && pszLevelName[1] == '_') {
if (m_nPlayersMin < 2) {
m_nPlayersMin = 2;
}
if (m_nPlayersMax > 4) {
m_nPlayersMax = 4;
}
if (m_nPlayersMax < m_nPlayersMin) {
m_nPlayersMax = m_nPlayersMin;
}
} else {
m_nPlayersMin = 1;
m_nPlayersMax = 1;
}
// Read in the side info for each side
Side side;
for (side = ksideNeutral; side < kcSides; side++) {
if (side == ksideNeutral) {
LoadSideInfo(pini, "sideNeutral", &m_asidi[side]);
} else {
char szSideName[] = "side1";
szSideName[4] = '0' + side;
LoadSideInfo(pini, szSideName, &m_asidi[side]);
}
}
// If there is no human side, assume it is side 1
// because gpplrLocal has to be set to something (because our code is intolerant)
bool fHumanFound = false;
for (side = ksideNeutral; side < kcSides; side++) {
if (m_asidi[side].nIntelligence == knIntelligenceHuman)
fHumanFound = true;
}
if (!fHumanFound)
m_asidi[kside1].nIntelligence = knIntelligenceHuman;
}
if (piniLoaded == NULL)
delete pini;
return fSuccess;
}
// Our program entry point
// This entry point is just a wrapper around the evolution routines.
// It sets up the input parameters as well as the output file, and otherwise just calls the routines to run the evolution.
int main(int argc, char* argv[]) {
int result; // Just a number for return values
//******************//
// Input parameters //
//******************//
// Read the input parameters file, named "params.ini" by default.
// If there is a command line argument, assume that it is the filename for the parameters file.
IniReader inifile;
if (argc > 1)
inifile.read(argv[1]);
else
inifile.read("params.ini");
// Values in the ini file can be set using the following command:
// inifile.setparam("desiredh", "Cosmology", 1);
// First parameter is the key name, the second is the section name, and the third is the value, either an integer, string or double
// Set up the cosmological parameters
Parameters myParams(inifile);
// Figure out if we're going to postprocess or not
bool dopostprocess = inifile.getiniBool("postprocess", false, "Single");
// Turn off post-processing for now
if(dopostprocess)
dopostprocess = false;
//**************//
// Output class //
//**************//
/*
// Set up the filenames to output
string outputdir = inifile.getiniString("logdir", "logs", "Function");
string basename = inifile.getiniString("runname", "run", "Function");
string postname = inifile.getiniString("postname", "d", "Function"); // Only used if dopostprocess is true
// Go and find our appropriate file name (using 4 digit numbers as the default)
string outputname = getfilename(outputdir, basename, postname, inifile.getiniInt("numberpad", 4, "Function"), dopostprocess);
// Set up the output class
std::string parsestring = inifile.getiniString("outputclass", "BasicDump", "Single");
Output *myOutput;
if (parsestring == "BasicDump")
myOutput = new BasicDump(dopostprocess, outputname, postname);
else
myOutput = new BasicDump(dopostprocess, outputname, postname); // BasicDump is the default
// Check that output is a go
if (!myOutput->filesready()) {
// End gracefully if not
cout << "Unable to open files for output." << endl;
delete myOutput;
return -1;
}
*/
Print2Memory myOutput;
// Load SN1a data
// Not so much here in a single run, but when doing multiple runs, it makes sense to store the SN1a data in memory
// rather than reading the file each time it's needed.
// Here, we load up the SN1a data (if postprocessing is true)
vector<vector<double> > SN1adata;
if (dopostprocess) {
string sn1afile = inifile.getiniString("union21", "SCPUnion2.1_mu_vs_z.txt", "Function");
if (loadSN1adata(sn1afile, SN1adata) != 0) {
// Could not find data file
myOutput.printlog("Warning: cannot find Union2.1 SN1a data file.");
cout << "Warning: cannot find Union2.1 SN1a data file." << endl;
}
}
//*******************//
// Do the evolution! //
//*******************//
// Print some stuff to the screen
cout << "Beginning evolution." << endl;
//cout << "Outputting to " << outputname << endl;
// Start timing!
boost::timer::cpu_timer myTimer;
// parameter name to be dialed
string paramname = "phi0";
// Section name of dialed parameter
string paramsection = "Cosmology";
// Value of the parameter which will be returned as the sequestering-compatible parameter
double param_seq;
// Start value of the parameter to be dialed
double paramstart = inifile.getiniDouble("paramstart", 0.0, "Seq");
double paramend = inifile.getiniDouble("paramend", 2.5, "Seq");
// Required accuracy of the sequestering constraint
int maxSteps = inifile.getiniInt("maxSteps", 2000, "Seq");
double DeltaParam = ( paramend - paramstart) / maxSteps;
int Steps = 0;
int NRflag = 0;
double param = paramstart;
double histIntRicciScalar;
vector<double> results;
/*
ofstream dumpconv;
dumpconv.open( inifile.getiniString("dumpdir", "testconv", "Seq") + "/" + inifile.getiniString("dumpfilename", "test.dat", "Seq") );
string p1_name = "mass";
string p1_section = "Quintessence";
string p2_name = "Omegakh2";
string p2_section = "Cosmology";
double p1_min = inifile.getiniDouble("p1_min", 0.0, "Seq");
double p1_max = inifile.getiniDouble("p1_max", 0.0, "Seq");
double delta_p1 = (p1_max - p1_min)/inifile.getiniDouble("p1_n", 10.0, "Seq");
double p2_min = inifile.getiniDouble("p2_min", 0.0, "Seq");
double p2_max = inifile.getiniDouble("p2_max", 0.0, "Seq");
double delta_p2 = (p2_max - p2_min)/inifile.getiniDouble("p2_n", 10.0, "Seq");
std::cout << p1_name << " = " << p1_min << " " << p1_max << " " << delta_p1 << "(logspace)" << std::endl;
std::cout << p2_name << " = " << p2_min << " " << p2_max << " " << delta_p2 << std::endl;
for(double p1 = p1_min; p1 < p1_max; p1 += delta_p1){
inifile.setparam(p1_name,p1_section,pow(10.0,p1));
for(double p2 = p2_min; p2 < p2_max; p2 += delta_p2){
inifile.setparam("evtoend","Seq",true);
inifile.setparam(p2_name,p2_section,p2);
Parameters myParams_1(inifile);
results = doEvolution(inifile, myParams_1, myOutput, SN1adata, dopostprocess);
// Now do a run to get the likelihood
inifile.setparam("evtoend","Seq",false);
Parameters myParams_2(inifile);
doEvolution(inifile, myParams_2, myOutput, SN1adata, true);
dumpconv << p1 << " " << p2 << " ";
for(int n = 0; n < results.size(); n++)
dumpconv << results[n] << " ";
dumpconv << myOutput.getvalue("combinationchi", 0.0);
dumpconv << std::endl;
}
dumpconv << std::endl;
}
*/
// HOPEFULLY, A ROUTINE TO FIND A SEQUESTERING SOLUTION VIA SOME MCMC-ISH METHOD.
ofstream dumpconv;
dumpconv.open( inifile.getiniString("dumpdir", "testconv", "Seq") + "/" + inifile.getiniString("dumpfilename", "test.dat", "Seq") );
double HIRl_p, HIRl_c = 1000, Omk_p, tmax, w0, amax;
double HIRl_t = inifile.getiniDouble("HIRt", 0.1, "Seq");
double p1_min = inifile.getiniDouble("p1_min", 0.0, "Seq");
double p1_max = inifile.getiniDouble("p1_max", 0.0, "Seq");
string p1_name = "mass";
string p1_section = "Quintessence";
double delta_p1 = (p1_max - p1_min)/inifile.getiniDouble("p1_n", 10.0, "Seq");
double p2_min = inifile.getiniDouble("p2_min", 0.0, "Seq");
double p2_max = inifile.getiniDouble("p2_max", 0.0, "Seq");
double p2_sigma = (p2_max - p2_min) / 100.0;
double Omk = p2_min;
double tarmfrac, a_now;
for(double p1 = p1_min; p1 < p1_max; p1 += delta_p1){
inifile.setparam(p1_name,p1_section,pow(10.0,p1));
Omk = p2_min + (p2_max - p2_min) * 0.5 + NormalRand() * p2_sigma;
HIRl_c = 1000;
while(true){
// Pick a new Omk that is inside the prior range
while(true){
Omk_p = Omk + NormalRand() * p2_sigma;
if(Omk_p <= p2_max && Omk_p >= p1_min)
break;
}
// Now that we have a sensible choice of Omk,
// run the evolver...
inifile.setparam("evtoend","Seq",true);
inifile.setparam("Omegakh2","Cosmology",Omk_p);
Parameters myParams_1(inifile);
results = doEvolution(inifile, myParams_1, myOutput, SN1adata, false);
// ... and pull out the value of <R>
HIRl_p = log10(abs(results[1]));
// If <R> for this choice of Omk is smaller than the previous one,
// then keep it.
if(HIRl_p < HIRl_c){
Omk = Omk_p;
HIRl_c = HIRl_p;
}
// If <R> is smaller than te desired threshold "error",
// then we have found a sequestering solution.
if(HIRl_c < HIRl_t){
amax = results[4];
w0 = results[5];
tmax = results[6];
tarmfrac = results[7];
a_now = results[8];
break;
}
}
inifile.setparam("evtoend","Seq",false);
Parameters myParams_2(inifile);
doEvolution(inifile, myParams_2, myOutput, SN1adata, true);
dumpconv << p1 << " " << Omk << " " << HIRl_c << " ";
dumpconv << exp(-0.5 * myOutput.getvalue("combinationchi", 0.0) ) << " ";
dumpconv << amax << " " << tmax << " " << w0 << " " << tarmfrac << " " << a_now << endl;
/*
1: mass
2: Omk
3: <R>
4: L
5: amax
6: tmax
7: w0
*/
}
dumpconv.close();
if(NRflag == 0)
std::cout << "histIntRicciScalar = " << histIntRicciScalar << endl;
// Stop timing
myTimer.stop();
result = (int)results[0];
// Interpret the result of the evolution
if (result == 0) {
// Success! Print a nice message
myOutput.printfinish(myTimer.elapsed().wall / 1e6);
cout << setprecision(4) << "Evolution complete in " << myTimer.elapsed().wall / 1e6 << " milliseconds." << endl;
}
else if (result == -1) {
// Initialization error
cout << "Error initializing model; terminating." << endl;
}
else if (result == 1) {
// Integration error
cout << "Integration error; terminating." << endl;
}
else if (result == 2) {
// NAN error
cout << "NAN error; terminating." << endl;
}
else if (result == 3) {
// Did not get t a = 1 error
cout << "Did not evolve to a = 1 within appropriate conformal time; terminating." << endl;
}
else if (result == 4) {
// Invalid state error
cout << "Invalid state reached; terminating." << endl;
}
else if (result == 5) {
// Invalid state error
cout << "Error integrating distance measures; terminating." << endl;
}
//**********//
// Clean up //
//**********//
// No memory leaks!
// delete *myOutput;
// Exit gracefully
return 0;
}
bool MissionList::GetMissionDescription(int i, MissionDescription *pmd) {
PdbItem *ppdbi;
LvlItem *plvli = FindLevelItem(i, &ppdbi);
if (plvli == NULL) {
return false;
}
if (!gppackm->Mount(gpakr, &ppdbi->packid)) {
return false;
}
const char *pszName;
switch (plvli->mt) {
case kmtStory:
pszName = "Story Missions";
break;
case kmtMultiplayerChallenge:
case kmtChallenge:
pszName = "Challenge Missions";
break;
case kmtDemo:
pszName = "Demo Missions";
break;
case kmtMultiplayerAddOn:
case kmtAddOn:
pszName = ppdbi->pszTitle;
if (strlen(pszName) == 0) {
pszName = ExtractPackTitle(&ppdbi->packid);
if (pszName == NULL) {
pszName = "Add-On Mission Pack";
}
}
break;
default:
pszName = "<untitled>";
break;
}
strncpyz(pmd->szPackName, pszName, sizeof(pmd->szPackName));
pmd->mt = plvli->mt;
IniReader *pini = LoadIniFile(gpakr, plvli->pszFilename);
if (pini == NULL) {
gppackm->Unmount(gpakr, &ppdbi->packid);
return false;
}
strncpyz(pmd->szLvlTitle, "<untitled>", sizeof(pmd->szLvlTitle));
pini->GetPropertyValue("General", "Title", pmd->szLvlTitle,
sizeof(pmd->szLvlTitle));
if (IsMultiplayerMissionType(plvli->mt)) {
pmd->cPlayersMin = 2;
pini->GetPropertyValue("General", "MinPlayers", "%d",
&pmd->cPlayersMin);
if (pmd->cPlayersMin < 2) {
pmd->cPlayersMin = 2;
}
pmd->cPlayersMax = 2;
pini->GetPropertyValue("General", "MaxPlayers", "%d",
&pmd->cPlayersMax);
if (pmd->cPlayersMax > 4) {
pmd->cPlayersMax = 4;
}
} else {
pmd->cPlayersMin = 1;
pmd->cPlayersMax = 1;
}
delete pini;
gppackm->Unmount(gpakr, &ppdbi->packid);
return true;
}
// Our program entry point
int main(int argc, char* argv[]) {
// Read the params.ini file
// If there is a command line argument, assume that it is a different file than params.ini
IniReader inifile;
if (argc > 1)
inifile.read(argv[1]);
else
inifile.read("params.ini");
// Set up the integrator
Integrator *myIntegrator = new Integrator;
// Set up the equations of motion/model class
// Model *myModel = new Quintessence();
Model *myModel = new QuintessenceH();
// Model *myModel = new LambdaCDM();
// Set up the parameters - OmegaM, Tgamma, OmegaK, z_init, h (of H_0 = h * 100 km/s/Mpc) and the model
Parameters *myParams = new Parameters(inifile.getiniDouble("Omegam", 0.3, "general"),
inifile.getiniDouble("Tgamma", 2.72548, "general"), 0.01, 1.0e4, 0.7);
// Load the model and parameters into a class to pass into the integration routine
IntParams *myIntParams = new IntParams(*myParams, *myModel);
// Set up the initial conditions
// We use conformal time for our time coordinate. To make things easier, we start at tau = 0.
double starttime = 0.0;
// We don't want to integrate forever; specify an endtime in conformal time. I've chosen 100 here; this should
// be chosen to correspond to about twice as long as you'd except the integration to take.
// Note that we'll actually be checking to stop integration when the energy fraction of matter is roughly correct (a >= 1)
double endtime = 10.0;
// The initial conditions is specified by values for the initial a, \phi, and \dot{\phi}
// where the overdot is a derivative with respect to conformal time.
// Rather than setting a, it's simpler to set a redshift to begin at, and compute a from there, noting that 1 + z = a_{today}/a
// and a_{today} = 1 by choice. This choice is specified in myParams.
// \phi and \dot{\phi} will need to be set based on the model
double phi0 = 0.01;
double phidot0 = 0.0;
// The data array stores a, \phi, and \dot{phi} through the evolution. The fourth parameter is an initial value of \dot{a}/a,
// which may be necessary in some models.
double data[4] = { 1.0 / (1.0 + myParams->z0()), phi0, phidot0, 0.0 };
// Set up the filenames to output
string outputdir = "logs";
string basename = "run";
// Go and find our appropriate file name (using 4 digit numbers)
string outputname = getfilename(outputdir, basename, 4);
// Set up the output class
Output *myOutput = new BasicDump(outputname);
// Check that output is a go
if (!myOutput->filesready()) {
cerr << "Unable to open files for output." << endl;
return -1;
}
// Set up the consistency check class
// Consistency *myChecker = new Consistency();
Consistency *myChecker = new SimpleCheck();
// Allow the model to initialize itself
int initresult = myModel->init(data, starttime, *myParams);
if (initresult != 0) {
cerr << "Unable to initialize model." << endl;
return -1;
}
// Get the output class to write out information on the run
myOutput->printinfo(data, *myIntParams);
// Allow the model class to write out any information on the run
myOutput->printlog(myModel->description());
// Start timing!
boost::timer::cpu_timer myTimer;
// Do the evolution!
int result = BeginEvolution(*myIntegrator, *myIntParams, data, starttime, endtime, *myOutput, *myChecker);
// Print a goodbye message, using time in milliseconds
myTimer.stop();
myOutput->printfinish(myTimer.elapsed().wall / 1e6);
// Clean up
delete myChecker;
delete myOutput;
delete myIntParams;
delete myParams;
delete myModel;
delete myIntegrator;
// Exit gracefully with result from integration
return result;
}
// Our program entry point
int main(int argc, char* argv[]) {
// Start timing!
boost::timer::cpu_timer myTimer;
//******************//
// Input parameters //
//******************//
// Read the input parameters file, named "params.ini" by default.
// If there is a command line argument, assume that it is the filename for the parameters file.
IniReader inifile;
string paramsfile;
if (argc > 1)
paramsfile = argv[1];
else
paramsfile = "params.ini";
inifile.read(paramsfile.c_str());
//**************//
// Declarations //
//**************//
// Print2Memory is used for MCMC outputting
Print2Memory myOutput;
// Seed random number generator
RNGtool.seed(time(NULL));
// Output directories and filenames
string chaindir = inifile.getiniString("chaindir", "chains", "MCMC");
string chainsubdir = inifile.getiniString("chainsubdir", "run1", "MCMC");
string outputdir = chaindir + "/" + chainsubdir;
string basename = inifile.getiniString("chainprefix", "chain", "MCMC");
string priorsfile = inifile.getiniString("priorsfile", "priors.txt", "MCMC");
// If the priors file doesn't exist, abort
// Make sure that the directories exist
if (!boost::filesystem::exists(priorsfile)) {
cout << "Priors file (" << priorsfile << ") does not exist. Aborting." << endl;
return -1;
}
// Make sure that the directories exist
if (!boost::filesystem::exists(chaindir + "/")) {
// Directory doesn't exist. Make it.
boost::filesystem::create_directory(chaindir);
std::cout << "Creating directory " << chaindir << "/" << std::endl;
}
if (!boost::filesystem::exists(outputdir + "/")) {
// Directory doesn't exist. Make it.
boost::filesystem::create_directory(outputdir);
std::cout << "Creating directory " << outputdir << "/" << std::endl;
}
// Copy the params.ini and priors file being used into the subdir
if (boost::filesystem::exists(paramsfile.c_str())) {
boost::filesystem::copy_file(paramsfile, outputdir + "/params.ini", boost::filesystem::copy_option::overwrite_if_exists);
boost::filesystem::copy_file(priorsfile, outputdir + "/priors.txt", boost::filesystem::copy_option::overwrite_if_exists);
}
// MCMC parameters
// Number of MCMC steps to burn
int MCMCburninsteps = inifile.getiniInt("MCMCburninsteps", 1000, "MCMC");
// Number of MCMC steps to take
int MCMCnumsteps = inifile.getiniInt("MCMCnumsteps", 40000, "MCMC");
// Number of MCMC chains
int MCMCnumchains = inifile.getiniInt("numchains", 5, "MCMC");
// Various variables
int MCMCstep, MCMCaccept_counter;
double lower, upper;
bool usingSN1a;
// Variables for holding the current and proposed likelihoods, and their ratio
double L_current, L_proposed, LikelihoodRatio;
// Progressbar stuff
bool showprogress = inifile.getiniBool("progress", true, "MCMC");
float progress = 0.0;
int barcount = 0;
//****************//
// Initialization //
//****************//
// Get the priors
ifstream priorsin;
string line;
priorsin.open(priorsfile.c_str());
vector<PARAMPRIORS> spriors;
string dummy;
if(priorsin){
while(!priorsin.eof()){
// Extract the line
getline(priorsin, line);
// Check whether the line is a comment
if (line[0] != '#' && line.length() > 0) {
if (line[0] == 'L' && line[1] == ' ') {
// Log parameter
// Convert the string into a stringstream for extraction
stringstream stream(line);
PARAMPRIORS temp;
stream >> dummy >> temp.section >> temp.name >> temp.lower >> temp.upper >> temp.sigma;
temp.logparam = true;
// Make sure that the upper and lower bounds are positive
if (temp.upper < 0 or temp.lower < 0) {
cout << "Error: bounds for " << temp.name << " must be positive in order to investigate parameter in log space. Terminating." << endl;
return -1;
}
spriors.push_back(temp);
} else {
// Convert the string into a stringstream for extraction
stringstream stream(line);
PARAMPRIORS temp;
stream >> temp.section >> temp.name >> temp.lower >> temp.upper >> temp.sigma;
temp.logparam = false;
spriors.push_back(temp);
}
}
}
// This is the workhorse of the code.
// It takes in the input parameters and an output object, and runs everything from there.
// This modularization is set up so that anybody can call the evolution routines.
//
// Input parameters:
// inifile: the input parameters
// params: class containing cosmological parameters (somewhat degenerate with inifile, but these values won't be read from inifile)
// output: the outputting class
// postprocess: whether or not to perform postprocessing
//
// Return values:
// 0: success
// -1: error in initialization
// 1: Integration error
// 2: NAN error
// 3: Did not get to a = 1 in allotted time
// 4: Model reports invalid state
// 5: Error in postprocessing integration of distance measures
int doEvolution(IniReader& inifile, Parameters& params, Output& output, vector<vector<double> > &SN1adata, bool postprocess) {
//****************//
// Initialization //
//****************//
// Set up the integrator
Integrator myIntegrator;
// Set up the model class
Model *myModel;
std::string parsestring = inifile.getiniString("model", "LambdaCDM", "Cosmology");
if (parsestring == "Quintessence")
myModel = new Quintessence();
else if (parsestring == "LinearW")
myModel = new LinearW();
else if (parsestring == "Kessence")
myModel = new Kessence();
else if (parsestring == "KGB")
myModel = new KGB();
else if (parsestring == "Fr")
myModel = new Fr();
else
myModel = new LambdaCDM(); // LambdaCDM is the default
// Load the model and parameters into a class to pass into the integration routine
IntParams myIntParams(params, *myModel);
// Set up the consistency check class
parsestring = inifile.getiniString("consistencyclass", "None", "Function");
Consistency *myChecker;
if (parsestring == "SimpleCheck")
myChecker = new SimpleCheck();
else
myChecker = new Consistency(); // Default option, which has no checking
// Create vectors for redshift and hubble
vector<double> redshift;
vector<double> hubble;
int result = 0; // For information coming back from functions
//********************//
// Initial Conditions //
//********************//
// The initial value of a is extracted from the starting redshift
// The initial values of \phi and \dot{\phi} are read from the input parameters
double phi0 = inifile.getiniDouble("phi0", 0.0, "Cosmology");
double phidot0 = inifile.getiniDouble("phidot0", 0.0, "Cosmology");
double data[4] = { 1.0 / (1.0 + params.z0()), phi0, phidot0, 0.0 };
// The data array stores a, \phi, \dot{phi} and H through the evolution
// H is calculated in the initialization of the model
// Start and end times
double starttime = inifile.getiniDouble("starttime", 0.0, "Function");
double endtime = starttime + inifile.getiniDouble("maxtime", 10.0, "Function");
// Get the output class to write out information on the run
output.printinfo(data, params);
// Allow the model to initialize itself
result = myModel->init(data, starttime, params, inifile, output);
if (result != 0) {
delete myChecker;
delete myModel;
return -1;
}
// Check that the model has an internally consistent state with the initial data (it should have aborted already if so, but be safe)
if (myModel->isvalidconfig(data) == false) {
delete myChecker;
delete myModel;
return 4;
}
// Write the model name to the output log
output.printvalue("Model", myModel->classname());
output.printlog(""); // Whitespace for prettiness
//***********//
// Evolution //
//***********//
// Do the evolution!
result = BeginEvolution(myIntegrator, myIntParams, data, starttime, endtime, output, *myChecker, hubble, redshift);
//*********************************//
// Clean up of Hubble and Redshift //
//*********************************//
if (result == 0) { // when the evolution was a success
// We have H and z starting with high z going to z = 0. We want these reversed.
reverse(hubble.begin(),hubble.end());
reverse(redshift.begin(),redshift.end());
// Update the parameters class with the new hubble value
params.seth(hubble[0]);
// Now go and report the actual density fractions and hubble parameter to the logs
output.printlog("Values from evolution of model are as follows:");
output.printvalue("modelh", params.geth());
output.printvalue("modelOmegaR", params.getOmegaR());
output.printvalue("modelOmegaM", params.getOmegaM());
output.printvalue("modelOmegaB", params.getOmegaB());
output.printvalue("modelOmegaK", params.getOmegaK());
output.printvalue("modelOmegaLambda", 1 - params.getOmegaK() - params.getOmegaR() - params.getOmegaM());
output.printlog("");
}
//*********************************//
// Post-processing: initialization //
//*********************************//
// Construct vectors for distance measures
int numrows = hubble.size();
vector<double> DC;
vector<double> DM;
vector<double> DA;
vector<double> DL;
vector<double> mu;
// Other distances that are computed
double rs; // sound horizon at z_CMB
double rd; // sound horizon at z_drag
//*******************//
// Distance measures //
//*******************//
if (result == 0 && postprocess) { // when the evolution was a success AND we're doing the postprocessing
// Get the output class to print any headings for postprocessing
output.postprintheading();
// Allocate space for the vectors
DC.reserve(numrows);
DM.reserve(numrows);
DA.reserve(numrows);
DL.reserve(numrows);
mu.reserve(numrows);
// Calculate distance measurements
result = PostProcessingDist(hubble, redshift, DC, DM, DA, DL, mu, rs, rd, params, output);
// Flag any errors
if (result == 1) result = 5;
}
//**************//
// chi^2 values //
//**************//
if (result == 0 && postprocess) { // when the distance calculations were a success AND we're doing the postprocessing
double BAOchi, BAOrchi, WMAPchi, Planckchi, Hubblechi, SNchi;
// Put in some whitespace!
output.printlog("");
// First, do chi^2 of WMAP and Planck distance posteriors
chi2CMB(redshift, DA, rs, output, params, WMAPchi, Planckchi);
// Next, do chi^2 of SN1a
SNchi = chi2SN1a(redshift, mu, output, inifile, SN1adata);
// Do chi^2 for hubble value
Hubblechi = chi2hubble(params, inifile.getiniDouble("desiredh", 0.7, "Cosmology"), inifile.getiniDouble("sigmah", 0.03, "Cosmology"), output);
// Finally, do chi^2 of BAO measurements
chi2BAO(rd, redshift, hubble, DA, params, output, BAOchi, BAOrchi);
// Calculate the combination chi^2 from the bitmask
double combination = 0;
unsigned int bitmask = params.getbitmask();
// 1 = SN1a
// 2 = BAO (using SDSS)
// 4 = BAO (using SDSSR)
// 8 = Hubble
// 16 = WMAP
// 32 = Planck
combination += (bitmask & 1) * SNchi;
combination += ((bitmask & 2) >> 1) * BAOchi;
combination += ((bitmask & 4) >> 2) * BAOrchi;
combination += ((bitmask & 8) >> 3) * Hubblechi;
combination += ((bitmask & 16) >> 4) * WMAPchi;
combination += ((bitmask & 32) >> 5) * Planckchi;
output.printvalue("combinationchi", combination);
output.printvalue("chicombo", (int) bitmask);
}
void GetParams(int argc, char* argv[], struct DATA *params){
// Get the parameter file:
IniReader inifile;
// If the user specified a param file at runtime
// then use that, else, use the default, params.ini
// (User specifies via ./EXE my_param.par)
if (argc > 1)
inifile.read(argv[1]);
else
inifile.read("params.ini");
// The numbers shown are the "default" values,
// if nothing can be found in the params.ini file.
params->h = inifile.getiniDouble("h",0.1);
params->ht = inifile.getiniDouble("ht",0.01);
params->derivsaccuracy = int(inifile.getiniDouble("derivsaccuracy",2));
params->imax = int(inifile.getiniDouble("imax",10));
params->cmax = int(inifile.getiniDouble("cmax",2));
params->ntimsteps = int(inifile.getiniDouble("ntimsteps",100));
params->pottype = int(inifile.getiniDouble("pottype",1));
params->inittype = int(inifile.getiniDouble("inittype",1));
params->evoltype = int(inifile.getiniDouble("evoltype",0));
params->field_lap_type = int(inifile.getiniDouble("field_lap_type",0));
params->eomtype = int(inifile.getiniDouble("eomtype",0));
params->screenfreq = int(inifile.getiniDouble("screenfreq",10));
params->filefreq = int(inifile.getiniDouble("filefreq",10));
params->thistfreq = int(inifile.getiniDouble("thistfreq",1));
params->potparam1 = inifile.getiniDouble("potparam1",0.0);
params->initparam1 = inifile.getiniDouble("initparam1",0.0);
params->OutDir = inifile.getiniString("OutDir","output/");
params->RunID = inifile.getiniString("RunID","run_01");
params->PoissSolnMethod = int(inifile.getiniDouble("PoissSolnMethod",1));
params->PoissSolnRelaxMethod = int(inifile.getiniDouble("PoissSolnRelaxMethod",1));
params->PoissSourceType = int(inifile.getiniDouble("PoissSourceType",1));
params->PoissAccuracy = inifile.getiniDouble("PoissAccuracy",1);
params->PossSolveFreq = inifile.getiniDouble("PossSolveFreq",1);
params->H0 = inifile.getiniDouble("H0",1.0);
params->hbar = inifile.getiniDouble("hbar",1.0);
// Make sure output directory exists.
// If it dosnt, this function will create it & tell you
// it got created
checkdirexists(params->OutDir);
params->flag = 0;
} // END GetParams()
