[cig-commits] [commit] master: Update param reader (8084667)
cig_noreply at geodynamics.org
cig_noreply at geodynamics.org
Tue Oct 21 16:27:35 PDT 2014
Repository : https://github.com/geodynamics/vc
On branch : master
Link : https://github.com/geodynamics/vc/compare/64c223c129f70f3916341f1ebdf52f6d2ae1deae...de41758e125fcac4ea5fb0935597c3b662ff523c
>---------------------------------------------------------------
commit 808466777de92edce79e31da393c673a57abae99
Author: Eric Heien <emheien at ucdavis.edu>
Date: Tue Oct 21 15:45:38 2014 -0700
Update param reader
>---------------------------------------------------------------
808466777de92edce79e31da393c673a57abae99
src/core/VCParams.cpp | 139 +++++++++++++++-----------------------------------
src/core/VCParams.h | 119 ++++++++++++++++--------------------------
2 files changed, 86 insertions(+), 172 deletions(-)
diff --git a/src/core/VCParams.cpp b/src/core/VCParams.cpp
index abaa39e..e9d7bf8 100644
--- a/src/core/VCParams.cpp
+++ b/src/core/VCParams.cpp
@@ -19,126 +19,71 @@
// DEALINGS IN THE SOFTWARE.
#include "VCParams.h"
-#include "ConfigFile.h"
/*!
Parse a configuration file for each of the possible parameters, assigning default values
for parameters that are not explicitly specified.
*/
void VCParams::read_params(const std::string ¶m_file_name) {
- std::string greens_method;
- ConfigFile param_file(param_file_name);
+ params = ConfigFile(param_file_name);
- valid = true;
+ // Call each of the parameter checks to set the default value if it's not already set
+ params.readSet<string>("sim.version", "");
- version = param_file.read<string>("sim.version", "");
+ params.readSet<double>("sim.time.start_year", 0.0);
+ params.readSet<double>("sim.time.end_year", 1000.0);
- year = param_file.read<double>("sim.time.start_year", 0.0);
- sim_end_year = param_file.read<double>("sim.time.end_year", 1000.0);
+ // in terms of # of events between state saves
+ params.readSet<int>("sim.system.checkpoint_period", 0);
+ params.readSet<string>("sim.system.checkpoint_prefix", "sim_state_");
- sanity_check = param_file.read<bool>("sim.system.sanity_check", false);
- use_transpose_matrix = param_file.read<bool>("sim.system.transpose_matrix", true);
- progress_period = param_file.read<unsigned int>("sim.system.progress_period", 0);
- checkpoint_period = param_file.read<int>("sim.system.checkpoint_period", 0);
- checkpoint_save_prefix = param_file.read<string>("sim.system.checkpoint_prefix", "sim_state_");
+ params.readSet<unsigned int>("sim.system.progress_period", 0);
- dynamic = param_file.read<double>("sim.friction.dynamic", INFINITY);
+ params.readSet<double>("sim.friction.dynamic", INFINITY);
- greens_method = param_file.read<string>("sim.greens.method", "standard");
- greens_infile = param_file.read<string>("sim.greens.input", "");
- greens_outfile = param_file.read<string>("sim.greens.output", "");
- do_normal_stress = param_file.read<bool>("sim.greens.use_normal", true);
- greens_kill_distance = param_file.read<double>("sim.greens.kill_distance", 0.0);
- greens_sample_distance = param_file.read<double>("sim.greens.sample_distance", 1000.0);
+ params.readSet<double>("sim.greens.kill_distance", 0.0);
+ double dist = params.readSet<double>("sim.greens.sample_distance", 1000.0);
- if (greens_sample_distance <= 0) greens_sample_distance = 1000;
+ if (dist <= 0) params.add("sim.greens.sample_distance", "1000.0");
- input_model_file = param_file.read<string>("sim.file.input", "");
- input_model_file_type = param_file.read<string>("sim.file.input_type", "");
- event_outfile = param_file.read<string>("sim.file.output_event", "");
- sweep_outfile = param_file.read<string>("sim.file.output_sweep", "");
- event_outfile_type = param_file.read<string>("sim.file.output_event_type", "");
-
- bass_max_generations = param_file.read<unsigned int>("sim.bass.max_generations", 0);
- bass_min_magnitude_mm = param_file.read<double>("sim.bass.mm", 4.0);
- bass_aftershock_strength_dm = param_file.read<double>("sim.bass.dm", 1.25);
- bass_frequency_scale_b = param_file.read<double>("sim.bass.b", 1.0);
- bass_aftershock_start_c = param_file.read<double>("sim.bass.c", 0.1);
- bass_time_decay_p = param_file.read<double>("sim.bass.p", 1.25);
- bass_distance_d = param_file.read<double>("sim.bass.d", 300);
- bass_distance_decay_q = param_file.read<double>("sim.bass.q", 1.35);
+ std::string greens_method = params.readSet<string>("sim.greens.method", "standard");
// Parse the Greens calculation method string
- if (!greens_method.compare("file")) {
- greens_calc_method = GREENS_FILE_PARSE;
- } else if (!greens_method.compare("bh")) {
- greens_calc_method = GREENS_CALC_BARNES_HUT;
- } else if (!greens_method.compare("standard")) {
- greens_calc_method = GREENS_CALC_STANDARD;
- } else {
- greens_calc_method = GREENS_CALC_UNDEFINED;
+ if (greens_method.compare("file") && greens_method.compare("bh") && greens_method.compare("standard")) {
+ params.add("sim.greens.method", "undefined");
}
- //std::cout << *this;
-}
+ // controls how much smoothing occurs in Barnes-Hut approximation
+ params.readSet<double>("sim.greens.bh_theta", 0.0);
+ params.readSet<string>("sim.greens.input", "");
-std::ostream &operator<<(std::ostream &os, const GreensCalcMethod &calc_method) {
- switch (calc_method) {
- case GREENS_FILE_PARSE:
- os << "file";
- break;
+ params.readSet<unsigned int>("sim.bass.max_generations", 0);
+ params.readSet<double>("sim.bass.mm", 4.0);
+ params.readSet<double>("sim.bass.dm", 1.25);
+ params.readSet<double>("sim.bass.b", 1.0);
+ params.readSet<double>("sim.bass.c", 0.1);
+ params.readSet<double>("sim.bass.p", 1.25);
+ params.readSet<double>("sim.bass.d", 300);
+ params.readSet<double>("sim.bass.q", 1.35);
- case GREENS_CALC_NONE:
- os << "none";
- break;
+ params.readSet<bool>("sim.system.sanity_check", false);
+ params.readSet<bool>("sim.greens.use_normal", true);
+ params.readSet<bool>("sim.system.transpose_matrix", true);
- case GREENS_CALC_BARNES_HUT:
- os << "bh";
- break;
+ params.readSet<string>("sim.file.input", "");
+ params.readSet<string>("sim.file.input_type", "");
- default:
- os << "undefined";
- break;
- }
+ params.readSet<string>("sim.greens.output", "");
+
+ params.readSet<string>("sim.file.output_event", "");
+ params.readSet<string>("sim.file.output_sweep", "");
+ params.readSet<string>("sim.file.output_event_type", "");
- return os;
}
-std::ostream &operator<<(std::ostream &os, const VCParams ¶ms) {
- os << "sim.version\t\t\t\t= " << params.version << "\n";
-
- os << "sim.time.start_year\t\t\t= " << params.year << "\n";
- os << "sim.time.end_year\t\t\t= " << params.sim_end_year << "\n";
-
- os << "sim.system.sanity_check\t\t\t= " << params.sanity_check << "\n";
- os << "sim.system.transpose_matrix\t\t= " << params.use_transpose_matrix << "\n";
- os << "sim.system.progress_period\t\t= " << params.progress_period << "\n";
- os << "sim.system.checkpoint_period\t\t= " << params.checkpoint_period << "\n";
- os << "sim.system.checkpoint_prefix\t\t= " << params.checkpoint_save_prefix << "\n";
-
- os << "sim.friction.dynamic\t\t\t= " << params.dynamic << "\n";
-
- os << "sim.greens.method\t\t\t= " << params.greens_calc_method << "\n";
- os << "sim.greens.input\t\t\t= " << params.greens_infile << "\n";
- os << "sim.greens.output\t\t\t= " << params.greens_outfile << "\n";
- os << "sim.greens.sample_distance\t\t= " << params.greens_sample_distance << "\n";
- os << "sim.greens.use_normal\t\t\t= " << params.do_normal_stress << "\n";
- os << "sim.greens.kill_distance\t\t= " << params.greens_kill_distance << "\n";
-
- os << "sim.file.input\t\t\t\t=" << params.input_model_file << "\n";
- os << "sim.file.input_type\t\t\t=" << params.input_model_file_type << "\n";
- os << "sim.file.output_event\t\t\t= " << params.event_outfile << "\n";
- os << "sim.file.output_sweep\t\t\t= " << params.sweep_outfile << "\n";
- os << "sim.file.output_event_type\t\t= " << params.event_outfile_type << "\n";
-
- os << "sim.bass.max_generations\t\t= " << params.bass_max_generations << "\n";
- os << "sim.bass.mm\t\t\t\t= " << params.bass_min_magnitude_mm << "\n";
- os << "sim.bass.dm\t\t\t\t= " << params.bass_aftershock_strength_dm << "\n";
- os << "sim.bass.b\t\t\t\t= " << params.bass_frequency_scale_b << "\n";
- os << "sim.bass.c\t\t\t\t= " << params.bass_aftershock_start_c << "\n";
- os << "sim.bass.p\t\t\t\t= " << params.bass_time_decay_p << "\n";
- os << "sim.bass.d\t\t\t\t= " << params.bass_distance_d << "\n";
- os << "sim.bass.q\t\t\t\t= " << params.bass_distance_decay_q << "\n";
-
- return os;
+void VCParams::write_params(const std::string ¶m_file_name) {
+ std::ofstream param_out_file(param_file_name.c_str());
+ param_out_file << params;
+
+ param_out_file.close();
}
diff --git a/src/core/VCParams.h b/src/core/VCParams.h
index 9829a2d..a702092 100644
--- a/src/core/VCParams.h
+++ b/src/core/VCParams.h
@@ -22,6 +22,7 @@
#include <string>
#include "QuakeLibUtil.h"
+#include "ConfigFile.h"
#ifndef _VCPARAMS_H_
#define _VCPARAMS_H_
@@ -40,153 +41,121 @@ enum GreensCalcMethod {
*/
class VCParams {
private:
- bool valid;
-
- std::string version;
-
- double year;
- double sim_end_year;
-
- int checkpoint_period; // in terms of # of events between state saves
- std::string checkpoint_save_prefix;
-
- unsigned int progress_period;
-
- double dynamic;
-
- double greens_kill_distance;
- double greens_sample_distance;
- GreensCalcMethod greens_calc_method;
- double barnes_hut_theta; // controls how much smoothing occurs in Barnes-Hutt approximation
- std::string greens_infile;
-
- unsigned int bass_max_generations;
- double bass_min_magnitude_mm;
- double bass_aftershock_strength_dm;
- double bass_frequency_scale_b;
- double bass_aftershock_start_c;
- double bass_time_decay_p;
- double bass_distance_d;
- double bass_distance_decay_q;
-
- bool sanity_check;
- bool do_normal_stress;
- bool use_transpose_matrix;
-
- std::string input_model_file;
- std::string input_model_file_type;
-
- std::string greens_outfile;
-
- std::string event_outfile, sweep_outfile;
- std::string event_outfile_type;
+ ConfigFile params;
public:
- VCParams(void) : valid(false) {};
+ VCParams(void) {};
void read_params(const std::string ¶m_file_name);
+ void write_params(const std::string ¶m_file_name);
std::string getVersion(void) const {
- return version;
+ return params.read<string>("sim.version");
};
double getSimStart(void) const {
- return year;
+ return params.read<double>("sim.time.start_year");
};
double getSimDuration(void) const {
- return sim_end_year;
+ return params.read<double>("sim.time.end_year");
};
+ // in terms of # of events between state saves
int getCheckpointPeriod(void) const {
- return checkpoint_period;
+ return params.read<int>("sim.system.checkpoint_period");
};
std::string getCheckpointPrefix(void) const {
- return checkpoint_save_prefix;
+ return params.read<string>("sim.system.checkpoint_prefix");
};
unsigned int getProgressPeriod(void) const {
- return progress_period;
+ return params.read<unsigned int>("sim.system.progress_period");
};
double getDynamic(void) const {
- return dynamic;
+ return params.read<double>("sim.friction.dynamic");
};
double getGreensKillDistance(void) const {
- return greens_kill_distance;
+ return params.read<double>("sim.greens.kill_distance");
};
double getGreensSampleDistance(void) const {
- return greens_sample_distance;
+ return params.read<double>("sim.greens.sample_distance");
};
GreensCalcMethod getGreensCalcMethod(void) const {
- return greens_calc_method;
+ std::string greens_method = params.read<string>("sim.greens.method");
+
+ // Parse the Greens calculation method string
+ if (!greens_method.compare("file")) return GREENS_FILE_PARSE;
+
+ if (!greens_method.compare("bh")) return GREENS_CALC_BARNES_HUT;
+
+ if (!greens_method.compare("standard")) return GREENS_CALC_STANDARD;
+
+ return GREENS_CALC_UNDEFINED;
};
+ // controls how much smoothing occurs in Barnes-Hut approximation
double getBarnesHutTheta(void) const {
- return barnes_hut_theta;
+ return params.read<double>("sim.greens.bh_theta");
};
std::string getGreensInputfile(void) const {
- return greens_infile;
+ return params.read<string>("sim.greens.input");
};
unsigned int getBASSMaxGenerations(void) const {
- return bass_max_generations;
+ return params.read<unsigned int>("sim.bass.max_generations");
};
double getBASSMinMagnitude(void) const {
- return bass_min_magnitude_mm;
+ return params.read<double>("sim.bass.mm");
};
double getBASSAftershockStrength(void) const {
- return bass_aftershock_strength_dm;
+ return params.read<double>("sim.bass.dm");
};
double getBASSFrequencyScale(void) const {
- return bass_frequency_scale_b;
+ return params.read<double>("sim.bass.b");
};
double getBASSAftershockStart(void) const {
- return bass_aftershock_start_c;
+ return params.read<double>("sim.bass.c");
};
double getBASSTimeDecay(void) const {
- return bass_time_decay_p;
+ return params.read<double>("sim.bass.p");
};
double getBASSDistance(void) const {
- return bass_distance_d;
+ return params.read<double>("sim.bass.d");
};
double getBASSDistanceDecay(void) const {
- return bass_distance_decay_q;
+ return params.read<double>("sim.bass.q");
};
bool doSanityCheck(void) const {
- return sanity_check;
+ return params.read<bool>("sim.system.sanity_check");
};
bool doNormalStress(void) const {
- return do_normal_stress;
+ return params.read<bool>("sim.greens.use_normal");
};
bool useTransposedMatrix(void) const {
- return use_transpose_matrix;
+ return params.read<bool>("sim.system.transpose_matrix");
};
std::string getModelFile(void) const {
- return input_model_file;
+ return params.read<string>("sim.file.input");
};
std::string getModelFileType(void) const {
- return input_model_file_type;
+ return params.read<string>("sim.file.input_type");
};
std::string getGreensOutfile(void) const {
- return greens_outfile;
+ return params.read<string>("sim.greens.output");
};
std::string getEventOutfile(void) const {
- return event_outfile;
+ return params.read<string>("sim.file.output_event");
};
std::string getSweepOutfile(void) const {
- return sweep_outfile;
+ return params.read<string>("sim.file.output_sweep");
};
std::string getEventOutfileType(void) const {
- return event_outfile_type;
+ return params.read<string>("sim.file.output_event_type");
};
-
- friend std::ostream &operator<<(std::ostream &os, const VCParams ¶ms);
};
-std::ostream &operator<<(std::ostream &os, const VCParams ¶ms);
-std::ostream &operator<<(std::ostream &os, const GreensCalcMethod &calc_method);
-
#endif
More information about the CIG-COMMITS
mailing list