00001
00009 #include "Parameters.h"
00010
00011 #include "../VariousFunctions/variousFunctions.h"
00012 #include "../Exceptions/error.h"
00013 #include "../Logging/Output.h"
00014 #include "../VariousFunctions/erf.h"
00015 #include <iostream>
00016
00017 using namespace std;
00018
00019
00023 template <typename T>
00024 bool ReadFromFile(T &variable, ifstream ¶meters_file, string variable_name, string default_value = "") {
00025
00026 Output::echo(0, "%s = ", variable_name.c_str());
00027
00028
00029 parameters_file.clear();
00030 parameters_file.seekg(0, ios::beg);
00031
00032 string word1="", word2="";
00033 string string_value;
00034 if (!parameters_file.eof()) {
00035 while (parameters_file) {
00036 word2 = word1;
00037
00038 parameters_file >> word1;
00039
00040 if (word1 == "=") {
00041 if (word2 == variable_name) {
00042 parameters_file >> string_value;
00043 break;
00044 }
00045 }
00046 }
00047 }
00048
00049 ostringstream ostr;
00050 if (string_value != "") {
00051 StrToVal(string_value, variable);
00052
00053 ostr << variable;
00054 Output::echo(0, "%s\n", ostr.str().c_str());
00055 return true;
00056 } else if (default_value != "") {
00057 StrToVal(default_value, variable);
00058
00059 ostr << variable;
00060 Output::echo(0, "%s (default value)\n", ostr.str().c_str());
00061 return true;
00062 } else {
00063 throw error_msg("ERROR", "Parameter value %s was not found.\n", variable_name.c_str());
00064 }
00065 }
00066
00067
00071 bool ParamStructure::Load_parameters(string filename) {
00072
00073 ifstream parameters_file;
00074 parameters_file.open(filename.c_str());
00075 if (parameters_file == NULL) {
00076 throw error_msg("CONST_FILE_OPEN_ERR", "Error reading %s for parameters.", filename.c_str());
00077 }
00078
00079 ReadFromFile(outputLvl, parameters_file, "outputLvl", "0");
00080
00081
00082 ReadFromFile(nDays, parameters_file, "nDays");
00083
00084 ReadFromFile(timeStep, parameters_file, "timeStep");
00085
00086 timeStep = timeStep/24.0;
00087
00088 totalIterationsNumber = int(nDays/timeStep)+1;
00089
00090 ReadFromFile(useRadialDifusion, parameters_file, "useRadialDifusion", "true");
00091 ReadFromFile(useAlphaDifusion, parameters_file, "useAlphaDifusion", "true");
00092 ReadFromFile(useEnergyDifusion, parameters_file, "useEnergyDifusion", "true");
00093 ReadFromFile(useEnergyAlphaMixedTerms, parameters_file, "usePcAlphaMixedTerms", "true");
00094
00095 if (useRadialDifusion) {
00096
00097 ReadFromFile(DLLType, parameters_file, "DLLType", "DLLT_B");
00098 }
00099
00100 Kp.AllocateMemory(totalIterationsNumber);
00101 ReadFromFile(useKp, parameters_file, "useKp", string("file"));
00102 if (useKp == "file") {
00103 ReadFromFile(fileKp, parameters_file, "fileKp");
00104 load_1d(Kp, fileKp, timeStep);
00105 } else {
00106 ReadFromFile(constKp, parameters_file, "constKp");
00107 Kp = constKp;
00108 }
00109
00110 ReadFromFile(useBf, parameters_file, "useBf", string("file"));
00111 Bf.AllocateMemory(totalIterationsNumber);
00112
00113 if (useBf == "file") {
00114
00115 ReadFromFile(fileBf, parameters_file, "fileBf");
00116
00117 load_1d(Bf, fileBf, timeStep);
00118 } else if (useBf == "constant") {
00119
00120 ReadFromFile(constBf, parameters_file, "constBf");
00121 Bf = constBf;
00122 } else {
00123 Bf = 1;
00124 }
00125 for (int i = 0; i < totalIterationsNumber; i++) {
00126 if (Bf[i] <= 0) {
00127 throw error_msg("BF_ERROR", "Negative or zero Bf[time[%d]=%f]=%f after loading and interpolation.\n", i, timeStep*i, Bf[i]);
00128 }
00129 }
00130
00131
00132 ReadFromFile(useLpp, parameters_file, "useLpp", string("No"));
00133 Lpp.AllocateMemory(totalIterationsNumber);
00134 if (useLpp == "file") {
00135 ReadFromFile(fileLpp, parameters_file, "fileLpp", string(""));
00136 load_1d(Lpp, fileLpp, timeStep);
00137 } else if (useLpp == "constant") {
00138 ReadFromFile(constLpp, parameters_file, "constLpp", "0.0");
00139 Lpp = constLpp;
00140 } else if (useLpp == "calculate" || str2bool(useLpp) == true) {
00141
00142 double Kp24 = 0;
00143 int iteration, back_it;
00144 for (iteration = 0; iteration < totalIterationsNumber; iteration++) {
00145 for (back_it = iteration; (fabs(timeStep * back_it - timeStep * iteration) <= 1.0) && (back_it >= 0); back_it--) {
00146 Kp24 = (Kp24 > Kp[back_it]) ? Kp24 : Kp[back_it];
00147 }
00148 Lpp[iteration] = (5.6 - 0.46*Kp24);
00149 Kp24 = 0;
00150 }
00151 } else {
00152 Lpp = 0;
00153 }
00154
00155 string usetau, usetauLpp;
00156
00157 ReadFromFile(usetau, parameters_file, "usetau", string("constant"));
00158 tau.AllocateMemory(totalIterationsNumber);
00159 if (usetau == "x/Kp") {
00160 double tmp_tau;
00161 ReadFromFile(tmp_tau, parameters_file, "tau");
00162 for (int i = 0; i < totalIterationsNumber; i++) {
00163 tau[i] = tmp_tau/max(Kp[i], 0.01);
00164 }
00165
00166 } if (str2bool(usetau) == true || usetau == "constant") {
00167 double tmp_tau;
00168 ReadFromFile(tmp_tau, parameters_file, "tau");
00169 tau = tmp_tau;
00170 } else {
00171 tauLpp = 1e99;
00172 }
00173
00174 ReadFromFile(usetauLpp, parameters_file, "usetauLpp", string("constant"));
00175 tauLpp.AllocateMemory(totalIterationsNumber);
00176 if (str2bool(usetauLpp) == true || usetauLpp == "constant") {
00177 double tmp_tauLpp;
00178 ReadFromFile(tmp_tauLpp, parameters_file, "tauLpp");
00179 tauLpp = tmp_tauLpp;
00180 } else {
00181 tauLpp = 1e99;
00182 }
00183
00184 ReadFromFile(outputModelMatrix, parameters_file, "outputModelMatrix", "false");
00185 ReadFromFile(NoNegative, parameters_file, "NoNegative", "false");
00186
00187
00188 ReadFromFile(general_Output_parameters.timeStep, parameters_file, "general_Output_parameters.timeStep", "1");
00189 ReadFromFile(general_Output_parameters.iterStep, parameters_file, "general_Output_parameters.iterStep", "1");
00190
00191 general_Output_parameters.timeStep = general_Output_parameters.timeStep/24.0;
00192 ReadFromFile(general_Output_parameters.logFileName, parameters_file, "general_Output_parameters.logFileName", "logfile.log");
00193 ReadFromFile(general_Output_parameters.folderName, parameters_file, "general_Output_parameters.folderName", "./");
00194 ReadFromFile(general_Output_parameters.fileName1D, parameters_file, "general_Output_parameters.fileName1D", "Out1D.plt");
00195
00196
00197 ReadFromFile(radialDiffusionGrid_type, parameters_file, "radialDiffusionGrid_type");
00198 ReadFromFile(localDiffusionsGrid_type, parameters_file, "localDiffusionsGrid_type");
00199
00200 if (radialDiffusionGrid_type == "GT_FILE")
00201 ReadFromFile(radialDiffusionGrid_filename, parameters_file, "radialDiffusionGrid_filename");
00202 if (localDiffusionsGrid_type == "GT_FILE")
00203 ReadFromFile(localDiffusionsGrid_filename, parameters_file, "localDiffusionsGrid_filename");
00204
00205 ReadFromFile(localDiffusionsGrid_L.name, parameters_file, "localDiffusionsGrid_L.name", string("L"));
00206 ReadFromFile(localDiffusionsGrid_L.size, parameters_file, "localDiffusionsGrid_L.size");
00207 ReadFromFile(localDiffusionsGrid_L.useLogScale, parameters_file, "localDiffusionsGrid_L.useLogScale");
00208 ReadFromFile(localDiffusionsGrid_L.min, parameters_file, "localDiffusionsGrid_L.min");
00209 ReadFromFile(localDiffusionsGrid_L.max, parameters_file, "localDiffusionsGrid_L.max");
00210
00211 ReadFromFile(localDiffusionsGrid_epc.name, parameters_file, "localDiffusionsGrid_epc.name", string("Energy, MeV"));
00212 ReadFromFile(localDiffusionsGrid_epc.size, parameters_file, "localDiffusionsGrid_epc.size");
00213 ReadFromFile(localDiffusionsGrid_epc.useLogScale, parameters_file, "localDiffusionsGrid_epc.useLogScale");
00214 ReadFromFile(localDiffusionsGrid_epc.min, parameters_file, "localDiffusionsGrid_epc.min");
00215 ReadFromFile(localDiffusionsGrid_epc.max, parameters_file, "localDiffusionsGrid_epc.max");
00216
00217 localDiffusionsGrid_pc = localDiffusionsGrid_epc;
00218 localDiffusionsGrid_pc.min = VF::pfunc(localDiffusionsGrid_epc.min);
00219 localDiffusionsGrid_pc.max = VF::pfunc(localDiffusionsGrid_epc.max);
00220
00221 ReadFromFile(localDiffusionsGrid_alpha.name, parameters_file, "localDiffusionsGrid_alpha.name", string("Pitch angle, deg"));
00222 ReadFromFile(localDiffusionsGrid_alpha.size, parameters_file, "localDiffusionsGrid_alpha.size");
00223 ReadFromFile(localDiffusionsGrid_alpha.useLogScale, parameters_file, "localDiffusionsGrid_alpha.useLogScale");
00224 ReadFromFile(localDiffusionsGrid_alpha.min, parameters_file, "localDiffusionsGrid_alpha.min");
00225 ReadFromFile(localDiffusionsGrid_alpha.max, parameters_file, "localDiffusionsGrid_alpha.max");
00226
00227
00228 localDiffusionsGrid_alpha.min = localDiffusionsGrid_alpha.min*VC::pi/180;
00229 localDiffusionsGrid_alpha.max = localDiffusionsGrid_alpha.max*VC::pi/180;
00230
00231
00232
00233
00234 radialDiffusionGrid_L = localDiffusionsGrid_L;
00235 radialDiffusionGrid_epc = localDiffusionsGrid_epc;
00236 radialDiffusionGrid_alpha = localDiffusionsGrid_alpha;
00237 radialDiffusionGrid_pc = localDiffusionsGrid_pc;
00238
00239
00240 ReadFromFile(L_LowerBoundaryCondition.type, parameters_file, "L_LowerBoundaryCondition.type", "BCT_CONSTANT_PSD");
00241 if (L_LowerBoundaryCondition.type == "BCT_FILE"
00242 || L_LowerBoundaryCondition.type == "BCT_FILE_GRID"
00243 || L_LowerBoundaryCondition.type == "BCT_FILE_CHANGES") {
00244 ReadFromFile(L_LowerBoundaryCondition.filename, parameters_file, "L_LowerBoundaryCondition.filename");
00245 } else {
00246 ReadFromFile(L_LowerBoundaryCondition.value, parameters_file, "L_LowerBoundaryCondition.value", "1e-22");
00247 }
00248
00249 ReadFromFile(L_UpperBoundaryCondition.type, parameters_file, "L_UpperBoundaryCondition.type", "BCT_CONSTANT_PSD");
00250 if (L_UpperBoundaryCondition.type == "BCT_FILE"
00251 || L_UpperBoundaryCondition.type == "BCT_FILE_GRID"
00252 || L_UpperBoundaryCondition.type == "BCT_FILE_CHANGES") {
00253 ReadFromFile(L_UpperBoundaryCondition.filename, parameters_file, "L_UpperBoundaryCondition.filename");
00254 } else {
00255 ReadFromFile(L_UpperBoundaryCondition.value, parameters_file, "L_UpperBoundaryCondition.value", "1e-22");
00256 }
00257
00258 ReadFromFile(pc_LowerBoundaryCondition.type, parameters_file, "pc_LowerBoundaryCondition.type", "BCT_CONSTANT_PSD");
00259 if (pc_LowerBoundaryCondition.type == "BCT_FILE"
00260 || pc_LowerBoundaryCondition.type == "BCT_FILE_GRID"
00261 || pc_LowerBoundaryCondition.type == "BCT_FILE_CHANGES") {
00262 ReadFromFile(pc_LowerBoundaryCondition.filename, parameters_file, "pc_LowerBoundaryCondition.filename");
00263 } else {
00264 ReadFromFile(pc_LowerBoundaryCondition.value, parameters_file, "pc_LowerBoundaryCondition.value", "1e-22");
00265 }
00266
00267 ReadFromFile(pc_UpperBoundaryCondition.type, parameters_file, "pc_UpperBoundaryCondition.type", "BCT_CONSTANT_PSD");
00268 if (pc_UpperBoundaryCondition.type == "BCT_FILE"
00269 || pc_UpperBoundaryCondition.type == "BCT_FILE_GRID"
00270 || pc_UpperBoundaryCondition.type == "BCT_FILE_CHANGES") {
00271 ReadFromFile(pc_UpperBoundaryCondition.filename, parameters_file, "pc_UpperBoundaryCondition.filename");
00272 } else {
00273 ReadFromFile(pc_UpperBoundaryCondition.value, parameters_file, "pc_UpperBoundaryCondition.value", "1e-22");
00274 }
00275
00276 ReadFromFile(alpha_LowerBoundaryCondition.type, parameters_file, "alpha_LowerBoundaryCondition.type", "BCT_CONSTANT_PSD");
00277 if (alpha_LowerBoundaryCondition.type == "BCT_FILE"
00278 || alpha_LowerBoundaryCondition.type == "BCT_FILE_GRID"
00279 || alpha_LowerBoundaryCondition.type == "BCT_FILE_CHANGES") {
00280 ReadFromFile(alpha_LowerBoundaryCondition.filename, parameters_file, "alpha_LowerBoundaryCondition.filename");
00281 } else {
00282 ReadFromFile(alpha_LowerBoundaryCondition.value, parameters_file, "alpha_LowerBoundaryCondition.value", "1e-22");
00283 }
00284
00285 ReadFromFile(alpha_UpperBoundaryCondition.type, parameters_file, "alpha_UpperBoundaryCondition.type", "BCT_CONSTANT_PSD");
00286 if (alpha_UpperBoundaryCondition.type == "BCT_FILE"
00287 || alpha_UpperBoundaryCondition.type == "BCT_FILE_GRID"
00288 || alpha_UpperBoundaryCondition.type == "BCT_FILE_CHANGES") {
00289 ReadFromFile(alpha_UpperBoundaryCondition.filename, parameters_file, "alpha_UpperBoundaryCondition.filename");
00290 } else {
00291 ReadFromFile(alpha_UpperBoundaryCondition.value, parameters_file, "alpha_UpperBoundaryCondition.value", "1e-22");
00292 }
00293
00294 ReadFromFile(psdRadialDiffusion.initial_PSD_Kp0, parameters_file, "psdRadialDiffusion.initial_PSD_Kp0", "0.0");
00295
00296 if (psdRadialDiffusion.initial_PSD_Kp0 <= 1e-99) {
00297 psdRadialDiffusion.initial_PSD_Kp0 = Kp[0];
00298 Output::echo(0, "psdRadialDiffusion.initial_PSD_Kp0 set to %f.\n", psdRadialDiffusion.initial_PSD_Kp0);
00299 }
00300
00301
00302 ReadFromFile(psdRadialDiffusion.initial_PSD_Type, parameters_file, "psdRadialDiffusion.initial_PSD_Type", "IPSDT_STEADY_STATE");
00303 if (psdRadialDiffusion.initial_PSD_Type == "IPSDT_STEADY_STATE"
00304 || psdRadialDiffusion.initial_PSD_Type == "IPSDT_STEADY_STATE_FROM_BOUNDARY") {
00305 ReadFromFile(psdRadialDiffusion.initial_PSD_tauSteadyState, parameters_file, "psdRadialDiffusion.initial_PSD_tauSteadyState", "0.0");
00306 if (psdRadialDiffusion.initial_PSD_tauSteadyState <= 1.e-98) {
00307 psdRadialDiffusion.initial_PSD_tauSteadyState = 4.0/psdRadialDiffusion.initial_PSD_Kp0;
00308 Output::echo(0, "psdRadialDiffusion.initial_PSD_tauSteadyState set to %f.\n", psdRadialDiffusion.initial_PSD_tauSteadyState);
00309 }
00310 } else if (psdRadialDiffusion.initial_PSD_Type == "IPSDT_FILE"
00311 || psdRadialDiffusion.initial_PSD_Type == "IPSDT_FILE_GRID"
00312 || psdRadialDiffusion.initial_PSD_Type == "IPSDT_ORBIT_FLUX_2D"){
00313 ReadFromFile(psdRadialDiffusion.initial_PSD_fileName, parameters_file, "psdRadialDiffusion.initial_PSD_fileName");
00314 }
00315
00316 ReadFromFile(psdRadialDiffusion.initial_PSD_some_constant_value, parameters_file, "psdRadialDiffusion.initial_PSD_some_constant_value", "1e-99");
00317 ReadFromFile(psdRadialDiffusion.initial_PSD_J_L7_function, parameters_file, "psdRadialDiffusion.initial_PSD_J_L7_function", "J_L7_corrected");
00318
00319 ReadFromFile(psdRadialDiffusion.initial_PSD_outer_psd, parameters_file, "psdRadialDiffusion.initial_PSD_outer_psd", "1.0");
00320 ReadFromFile(psdRadialDiffusion.initial_PSD_inner_psd, parameters_file, "psdRadialDiffusion.initial_PSD_inner_psd", "0.0");
00321
00322 ReadFromFile(psdRadialDiffusion.output_PSD_folderName, parameters_file, "psdRadialDiffusion.output_PSD_folderName", general_Output_parameters.folderName );
00323 ReadFromFile(psdRadialDiffusion.output_PSD_fileName4D, parameters_file, "psdRadialDiffusion.output_PSD_fileName4D", "out4d_rad.dat");
00324
00325 ReadFromFile(psdRadialDiffusion.output_PSD_timeStep, parameters_file, "psdRadialDiffusion.output_PSD_timeStep", "1");
00326
00327 psdRadialDiffusion.output_PSD_timeStep = psdRadialDiffusion.output_PSD_timeStep/24.0;
00328
00329 psdRadialDiffusion.approximationMethod = "AM_Split_C";
00330 psdRadialDiffusion.solutionMethod = "SM_Tridiag";
00331
00332
00333 psdLocalDiffusions.initial_PSD_Type = "IPSDT_CONSTANT";
00334 psdLocalDiffusions.initial_PSD_some_constant_value = psdRadialDiffusion.initial_PSD_some_constant_value;
00335
00336 ReadFromFile(psdLocalDiffusions.output_PSD_folderName, parameters_file, "psdLocalDiffusions.output_PSD_folderName", general_Output_parameters.folderName);
00337 ReadFromFile(psdLocalDiffusions.output_PSD_fileName4D, parameters_file, "psdLocalDiffusions.output_PSD_fileName4D", string("out4d.dat"));
00338
00339 ReadFromFile(psdLocalDiffusions.output_PSD_timeStep, parameters_file, "psdLocalDiffusions.output_PSD_timeStep", "1");
00340
00341 psdLocalDiffusions.output_PSD_timeStep = psdLocalDiffusions.output_PSD_timeStep/24.0;
00342
00343 ReadFromFile(psdLocalDiffusions.approximationMethod, parameters_file, "psdLocalDiffusions.approximationMethod", "AM_Split_C");
00344 if (psdLocalDiffusions.approximationMethod == "AM_Split_C" || psdLocalDiffusions.approximationMethod == "AM_Split_LR") {
00345 ReadFromFile(psdLocalDiffusions.solutionMethod, parameters_file, "psdLocalDiffusions.solutionMethod", "SM_Tridiag");
00346 } else {
00347 ReadFromFile(psdLocalDiffusions.solutionMethod, parameters_file, "psdLocalDiffusions.solutionMethod", "SM_Relaxation");
00348
00349 if (psdLocalDiffusions.solutionMethod == "SM_GMRES") {
00350 ReadFromFile(psdLocalDiffusions.SOL_maxiter, parameters_file, "psdLocalDiffusions.SOL_maxiter", "100");
00351 ReadFromFile(psdLocalDiffusions.SOL_i_max, parameters_file, "psdLocalDiffusions.SOL_i_max", "25");
00352 ReadFromFile(psdLocalDiffusions.SOL_max_iter_err, parameters_file, "psdLocalDiffusions.SOL_max_iter_err", "1e-1");
00353 }
00354 }
00355
00356
00357 ReadFromFile(sourcesAndLosses.SL_L_top, parameters_file, "sourcesAndLosses.SL_L_top", "false");
00358 if (sourcesAndLosses.SL_L_top) {
00359 ReadFromFile(sourcesAndLosses.SL_L_top_filename, parameters_file, "sourcesAndLosses.SL_L_top_filename");
00360 }
00361 ReadFromFile(sourcesAndLosses.SL_E_min, parameters_file, "sourcesAndLosses.SL_E_min", "false");
00362 if (sourcesAndLosses.SL_E_min) {
00363 ReadFromFile(sourcesAndLosses.SL_E_min_filename, parameters_file, "sourcesAndLosses.SL_E_min_filename");
00364 }
00365
00366
00367 ReadFromFile(interpolation.type, parameters_file, "interpolation.type");
00368 ReadFromFile(interpolation.useLog, parameters_file, "interpolation.useLog");
00369 ReadFromFile(interpolation.linearSplineCoef, parameters_file, "interpolation.linearSplineCoef");
00370 ReadFromFile(interpolation.maxSecondDerivative, parameters_file, "interpolation.maxSecondDerivative");
00371
00372
00373
00374
00375 parameters_file.seekg(0,ios::beg);
00376 string word1="", word2="";
00377 string string_value, dxx_parameters_file_name;
00378 if (parameters_file != NULL) {
00379 while (parameters_file) {
00380 word2 = word1;
00381
00382 parameters_file >> word1;
00383
00384 if (word1 == "=") {
00385 if (word2 == "CoeffFileName") {
00386 parameters_file >> dxx_parameters_file_name;
00387
00388
00389 DxxParamStructureList.push_back(DiffusionCoefficientParamStructure());
00390
00391
00392
00393
00394 DxxParamStructureList.back().Load_dxx_parameters(dxx_parameters_file_name);
00395
00396 }
00397 }
00398 }
00399 }
00400
00401 return true;
00402 }
00403
00404
00408 bool DiffusionCoefficientParamStructure::Load_dxx_parameters(string dxx_parameters_file_name) {
00409 ifstream dxx_parameters_file;
00410 dxx_parameters_file.open(dxx_parameters_file_name.c_str());
00411 if (dxx_parameters_file == NULL) {
00412 throw error_msg("DXX_PARAM_FILE_OPEN_ERR", "Error reading diffusion coefficients parameters file %s.", dxx_parameters_file_name.c_str());
00413 }
00414
00415 ReadFromFile(DxxType, dxx_parameters_file, "DxxType");
00416 ReadFromFile(DxxName, dxx_parameters_file, "DxxType");
00417
00418 ReadFromFile(waveType, dxx_parameters_file, "waveType");
00419 ReadFromFile(waveName, dxx_parameters_file, "waveType");
00420
00421 ReadFromFile(time_start, dxx_parameters_file, "time_start");
00422 ReadFromFile(time_end, dxx_parameters_file, "time_end");
00423
00424 ReadFromFile(useScale, dxx_parameters_file, "useScale", "false");
00425 if (useScale) {
00426 ReadFromFile(DxxKp , dxx_parameters_file, "DxxKp");
00427 }
00428
00429 ReadFromFile(loadOrCalculate, dxx_parameters_file, "loadOrCalculate");
00430
00431 ReadFromFile(filetype, dxx_parameters_file, "filetype");
00432 ReadFromFile(filename, dxx_parameters_file, "filename");
00433
00434 if (loadOrCalculate == "LOC_LOAD" || loadOrCalculate == "LOC_LOADORCALCULATE") {
00435 ReadFromFile(multiplicator, dxx_parameters_file, "multiplicator", "1.0");
00436 }
00437
00438 if (loadOrCalculate == "LOC_CALCULATE" || loadOrCalculate == "LOC_LOADORCALCULATE") {
00439 ReadFromFile(numberDensity, dxx_parameters_file, "numberDensity");
00440 ReadFromFile(MLT_averaging, dxx_parameters_file, "MLT_averaging");
00441 ReadFromFile(Omega_mType, dxx_parameters_file, "Omega_mType");
00442 ReadFromFile(Omega_m, dxx_parameters_file, "Omega_m");
00443 ReadFromFile(d_omega, dxx_parameters_file, "d_omega");
00444 ReadFromFile(omega_lc, dxx_parameters_file, "omega_lc");
00445 ReadFromFile(omega_uc, dxx_parameters_file, "omega_uc");
00446 ReadFromFile(eta1, dxx_parameters_file, "eta1");
00447 ReadFromFile(eta2, dxx_parameters_file, "eta2");
00448 ReadFromFile(eta3, dxx_parameters_file, "eta3");
00449 ReadFromFile(Bw, dxx_parameters_file, "Bw");
00450 ReadFromFile(BwFromLambda, dxx_parameters_file, "BwFromLambda");
00451 ReadFromFile(nint, dxx_parameters_file, "nint");
00452 ReadFromFile(lam_min, dxx_parameters_file, "lam_min", "0.0");
00453 ReadFromFile(lam_max, dxx_parameters_file, "lam_max");
00454 ReadFromFile(nu, dxx_parameters_file, "nu", "0.0");
00455 ReadFromFile(s, dxx_parameters_file, "sign");
00456 if (numberDensity == "ND_CONSTANT") {
00457 ReadFromFile(f, dxx_parameters_file, "f_ratio");
00458 }
00459 ReadFromFile(particle, dxx_parameters_file, "particle");
00460
00461 double sigma = (omega_uc - omega_lc) / (2.0 * d_omega);
00462 Output::echo(0, "sigma = %f\n", sigma);
00463 nu = erf(sigma)*sqrt(VC::pi);
00464 Output::echo(0, "nu = %f\n", nu);
00465
00466 if (Bw <= 0 && BwFromLambda == false) {
00467 throw error_msg("DXX_ERROR", "BwFromLambda is false and Bw = %f\n", Bw);
00468 } else if (BwFromLambda == true && Bw <= 0) {
00469 Bw = 1;
00470 }
00471
00472 }
00473
00474 return true;
00475 }
00476
00477
00481 void StrToVal(string input, double &place) {
00482 istringstream(input) >> place;
00483
00484 }
00485
00489 void StrToVal(string input, int &place) {
00490 istringstream(input) >> place;
00491
00492 }
00493
00497 void StrToVal(string input, string &place) {
00498 place = input;
00499
00500 }
00501
00505 void StrToVal(string input, bool &place) {
00506 place = str2bool(input);;
00507
00508 }
00509
00510
00514 bool str2bool(string str) {
00515 if (str == "Yes" || str == "yes" || str == "1" || str == "True" || str == "true") return true;
00516 else return false;
00517 }
00518
00522 string bool2str(bool b) {
00523 return (b==true)?"Yes":"No";
00524 }
00525
00526
00529 void load_1d(Matrix1D<double> &var, string filename, double dt, int var_size) {
00530
00531
00532 if (var_size != 0) {
00533
00534 var.AllocateMemory(var_size);
00535 } else {
00536
00537 var_size = var.size_x;
00538 }
00539
00540 ifstream input_1d(filename.c_str());
00541 if (input_1d != NULL) {
00542 vector <double> time1d, value1d;
00543 double time_tmp, value_tmp;
00544 while (!input_1d.eof()) {
00545
00546 input_1d >> time_tmp >> value_tmp;
00547 time1d.push_back(time_tmp);
00548 value1d.push_back(value_tmp);
00549 }
00550 double time;
00551 double a;
00552
00553 for (int it = 0; it < var.size_x; it++) {
00554 time = dt*it;
00555
00556 unsigned int i = 0;
00557 while (((++i) < (time1d.size()-1)) && time > time1d[i]) {
00558
00559 };
00560
00561 a = (time - time1d[i-1]) / (time1d[i] - time1d[i-1]);
00562 var[it] = value1d[i-1] + a*(value1d[i] - value1d[i-1]);
00563 }
00564 } else {
00565 throw error_msg("LOAD_1D_ERROR", "Load 1d file error: file not found %f\n", filename.c_str());
00566 }
00567 }