int main(int argc, char* argv[])
{
using namespace flexiblesusy;
using namespace softsusy;
typedef Two_scale algorithm_type;
CMSSM_input_parameters<algorithm_type> input;
set_command_line_parameters(argc, argv, input);
QedQcd oneset;
oneset.toMz();
CMSSM_spectrum_generator<algorithm_type> spectrum_generator;
spectrum_generator.set_precision_goal(1.0e-4);
spectrum_generator.set_beta_zero_threshold(1e-11);
spectrum_generator.set_max_iterations(0); // 0 == automatic
spectrum_generator.set_calculate_sm_masses(0); // 0 == no
spectrum_generator.set_parameter_output_scale(0); // 0 == susy scale
spectrum_generator.set_pole_mass_loop_order(2); // 2-loop
spectrum_generator.set_ewsb_loop_order(2); // 2-loop
spectrum_generator.set_beta_loop_order(2); // 2-loop
spectrum_generator.set_threshold_corrections_loop_order(1); // 1-loop
spectrum_generator.run(oneset, input);
const int exit_code = spectrum_generator.get_exit_code();
const CMSSM_slha<algorithm_type> model(spectrum_generator.get_model());
CMSSM_scales scales;
scales.HighScale = spectrum_generator.get_high_scale();
scales.SUSYScale = spectrum_generator.get_susy_scale();
scales.LowScale = spectrum_generator.get_low_scale();
// SLHA output
SLHAea::Coll slhaea(CMSSM_slha_io::fill_slhaea(model, oneset, scales));
std::cout << slhaea;
return exit_code;
}
int main() {
/// Header
cerr << "SOFTSUSY" << SOFTSUSY_VERSION
<< " Ben Allanach, Markus Bernhardt 2009\n";
cerr << "If you use SOFTSUSY, please refer to B.C. Allanach, ";
cerr << "Comput. Phys. Commun. 143 (2002) 305, hep-ph/0104145;\n";
cerr << "For RPV aspects, B.C. Allanach and M.A. Bernhardt, ";
cerr << "Comp. Phys. Commun. 181 (2010) 232, ";
cerr << "arXiv:0903.1805.\n";
cerr << "For RPV neutrino masses, B.C. Allanach, M. Hanussek and S. Kom,\n";
cerr << "Comput. Phys. Commun. 183 (2012) 785, arXiv:1109.3735 [hep-ph]\n";
/// Sets up exception handling
signal(SIGFPE, FPE_ExceptionHandler);
/// MIXING=1: CKM-mixing in up-sector
MIXING = 1;
/// Apply SUSY breaking conditions at GUT scale, where g_1=g_2
bool gaugeUnification = true;
/// Sets format of output: 3 decimal places
outputCharacteristics(3);
/// "try" catches errors in main program and prints them out
try {
QedQcd oneset; ///< See "lowe.h" for default parameter definitions
oneset.toMz(); ///< Runs SM fermion masses to MZ
/// Guess at GUT scale
double mxGuess = 2.e16;
/// Close to scenario IH S2 from arXiv:1106.4338
int sgnMu = 1;
double tanb = 20., a0 = 924., m12 = 500., m0 = 100.;
/// Define RpvNeutrino object
RpvNeutrino kw;
/// Set the CKM angles in Wolfenstein parameterisation
double lambda = 0.2272, aCkm = 0.818, rhobar = 0.221, etabar = 0.34;
kw.setAngles(lambda, aCkm, rhobar, etabar);
/// Set the GUT scale RPV SUSY couplings
kw.setLamPrime(1, 1, 1, 0.0395);
kw.setLamPrime(2, 1, 1, -0.018);
kw.setLamPrime(3, 1, 1, 0.019);
kw.setLamPrime(1, 3, 3, 3.0e-5);
kw.setLamPrime(2, 3, 3, 3.2e-5);
kw.setLamPrime(3, 3, 3, -3.5e-5);
/// Store inputs into one vector
DoubleVector pars(3); pars(1) = m0; pars(2) = m12; pars(3) = a0;
/// Outputs the RPV couplings required into the vector pars used by lowOrg
kw.rpvDisplay(pars);
/// Makes sure the neutrino mass ordering will be as expected in inverted
/// hierarchy output. If required, must be set before lowOrg is called
kw.setInvertedOutput();
/// Main driver routine: do the calculation
double mgut = kw.lowOrg(rpvSugraBcs, mxGuess, pars, sgnMu, tanb, oneset,
gaugeUnification);
/// Output the results in SLHA2 format
double qMax = 0.; char * modelIdent = (char *)"sugra";
int numPoints = 1; bool ewsbBCscale = false;
kw.lesHouchesAccordOutput(cout, modelIdent, pars, sgnMu, tanb, qMax,
numPoints, mgut, ewsbBCscale);
}
catch(const string & a) {
cout << a; exit(-1);
}
catch(const char *a) {
cout << a; exit(-1);
}
}
int main(int argc, const char* argv[])
{
using namespace flexiblesusy;
using namespace softsusy;
typedef Two_scale algorithm_type;
Command_line_options options(argc, argv);
if (options.must_print_model_info())
StandardModel_info::print(std::cout);
if (options.must_exit())
return options.status();
const std::string rgflow_file(options.get_rgflow_file());
const std::string slha_input_file(options.get_slha_input_file());
const std::string slha_output_file(options.get_slha_output_file());
const std::string spectrum_file(options.get_spectrum_file());
StandardModel_slha_io slha_io;
Spectrum_generator_settings spectrum_generator_settings;
QedQcd oneset;
StandardModel_input_parameters input;
if (slha_input_file.empty()) {
ERROR("No SLHA input file given!\n"
" Please provide one via the option --slha-input-file=");
return EXIT_FAILURE;
}
try {
slha_io.read_from_file(slha_input_file);
slha_io.fill(oneset);
slha_io.fill(input);
slha_io.fill(spectrum_generator_settings);
} catch (const Error& error) {
ERROR(error.what());
return EXIT_FAILURE;
}
oneset.toMz(); // run SM fermion masses to MZ
StandardModel_spectrum_generator<algorithm_type> spectrum_generator;
spectrum_generator.set_precision_goal(
spectrum_generator_settings.get(Spectrum_generator_settings::precision));
spectrum_generator.set_max_iterations(
spectrum_generator_settings.get(Spectrum_generator_settings::max_iterations));
spectrum_generator.set_calculate_sm_masses(
spectrum_generator_settings.get(Spectrum_generator_settings::calculate_sm_masses) >= 1.0);
spectrum_generator.set_input_scale(
slha_io.get_input_scale());
spectrum_generator.set_parameter_output_scale(
slha_io.get_parameter_output_scale());
spectrum_generator.set_pole_mass_loop_order(
spectrum_generator_settings.get(Spectrum_generator_settings::pole_mass_loop_order));
spectrum_generator.set_ewsb_loop_order(
spectrum_generator_settings.get(Spectrum_generator_settings::ewsb_loop_order));
spectrum_generator.set_beta_loop_order(
spectrum_generator_settings.get(Spectrum_generator_settings::beta_loop_order));
spectrum_generator.set_threshold_corrections_loop_order(
spectrum_generator_settings.get(Spectrum_generator_settings::threshold_corrections_loop_order));
spectrum_generator.set_higgs_2loop_corrections(
spectrum_generator_settings.get_higgs_2loop_corrections());
spectrum_generator.run(oneset, input);
const StandardModel_slha<algorithm_type> model(spectrum_generator.get_model());
const Problems<StandardModel_info::NUMBER_OF_PARTICLES>& problems
= spectrum_generator.get_problems();
// output
slha_io.set_spinfo(problems);
slha_io.set_sminputs(oneset);
slha_io.set_minpar(input);
slha_io.set_extpar(input);
if (!problems.have_problem()) {
slha_io.set_spectrum(model);
slha_io.set_extra(model);
}
if (slha_output_file.empty()) {
slha_io.write_to_stream(std::cout);
} else {
slha_io.write_to_file(slha_output_file);
}
if (!spectrum_file.empty())
spectrum_generator.write_spectrum(spectrum_file);
if (!rgflow_file.empty())
spectrum_generator.write_running_couplings(rgflow_file);
const int exit_code = spectrum_generator.get_exit_code();
return exit_code;
}
int main(int argc, const char* argv[])
{
using namespace flexiblesusy;
using namespace softsusy;
typedef Two_scale algorithm_type;
Command_line_options options(argc, argv);
if (options.must_print_model_info())
CNE6SSM_info::print(std::cout);
if (options.must_exit())
return options.status();
const std::string rgflow_file(options.get_rgflow_file());
const std::string slha_input_file(options.get_slha_input_file());
const std::string slha_output_file(options.get_slha_output_file());
const std::string spectrum_file(options.get_spectrum_file());
CNE6SSM_slha_io slha_io;
Spectrum_generator_settings spectrum_generator_settings;
QedQcd oneset;
CNE6SSM_semianalytic_input_parameters<algorithm_type> input;
if (slha_input_file.empty()) {
ERROR("No SLHA input file given!\n"
" Please provide one via the option --slha-input-file=");
return EXIT_FAILURE;
}
try {
slha_io.read_from_file(slha_input_file);
slha_io.fill(oneset);
slha_io.fill(input);
slha_io.fill(spectrum_generator_settings);
} catch (const Error& error) {
ERROR(error.what());
return EXIT_FAILURE;
}
oneset.toMz(); // run SM fermion masses to MZ
CNE6SSM_semianalytic_spectrum_generator<algorithm_type> spectrum_generator;
spectrum_generator.set_precision_goal(
spectrum_generator_settings.get(Spectrum_generator_settings::precision));
spectrum_generator.set_max_iterations(
spectrum_generator_settings.get(Spectrum_generator_settings::max_iterations));
spectrum_generator.set_calculate_sm_masses(
spectrum_generator_settings.get(Spectrum_generator_settings::calculate_sm_masses) >= 1.0);
spectrum_generator.set_force_output(
spectrum_generator_settings.get(Spectrum_generator_settings::force_output) >= 1.0);
spectrum_generator.set_parameter_output_scale(
slha_io.get_parameter_output_scale());
spectrum_generator.set_pole_mass_loop_order(
spectrum_generator_settings.get(Spectrum_generator_settings::pole_mass_loop_order));
spectrum_generator.set_ewsb_loop_order(
spectrum_generator_settings.get(Spectrum_generator_settings::ewsb_loop_order));
spectrum_generator.set_beta_loop_order(
spectrum_generator_settings.get(Spectrum_generator_settings::beta_loop_order));
spectrum_generator.set_threshold_corrections_loop_order(
spectrum_generator_settings.get(Spectrum_generator_settings::threshold_corrections_loop_order));
spectrum_generator.set_two_loop_corrections(
spectrum_generator_settings.get_two_loop_corrections());
// note
spectrum_generator.set_ewsb_iteration_precision(0.5);
spectrum_generator.run(oneset, input);
const CNE6SSM_semianalytic_slha<algorithm_type> model(spectrum_generator.get_model());
const Problems<CNE6SSM_info::NUMBER_OF_PARTICLES>& problems
= spectrum_generator.get_problems();
CNE6SSM_scales scales;
scales.HighScale = spectrum_generator.get_high_scale();
scales.SUSYScale = spectrum_generator.get_susy_scale();
scales.LowScale = spectrum_generator.get_low_scale();
// output
slha_io.set_spinfo(problems);
slha_io.set_sminputs(oneset);
slha_io.set_minpar(input);
slha_io.set_extpar(input);
if (!problems.have_problem() ||
spectrum_generator_settings.get(Spectrum_generator_settings::force_output)) {
slha_io.set_spectrum(model);
slha_io.set_extra(model, scales);
}
if (slha_output_file.empty()) {
slha_io.write_to_stream(std::cout);
} else {
slha_io.write_to_file(slha_output_file);
}
if (!spectrum_file.empty())
spectrum_generator.write_spectrum(spectrum_file);
if (!rgflow_file.empty())
spectrum_generator.write_running_couplings(rgflow_file);
// note
CNE6SSM_higgs_upper_bound upper_bound(model);
upper_bound.set_include_down_tadpoles(false);
upper_bound.set_include_exotic_tadpoles(false);
upper_bound.set_include_inert_singlet_tadpoles(false);
upper_bound.set_include_inert_neutral_higgs_tadpoles(false);
upper_bound.set_include_inert_charged_higgs_tadpoles(false);
std::cout << "tree level upper bound = "
<< upper_bound.calculate_tree_level_upper_bound() << '\n';
std::cout << "1-lp upper bound (only stops) = "
<< upper_bound.calculate_one_loop_upper_bound() << '\n';
upper_bound.set_include_down_tadpoles(true);
std::cout << "1-lp upper bound (stops + sbottoms) = "
<< upper_bound.calculate_one_loop_upper_bound() << '\n';
upper_bound.set_include_all_SM_generations(true);
upper_bound.set_include_down_tadpoles(false);
std::cout << "1-lp upper bound (all up squarks) = "
<< upper_bound.calculate_one_loop_upper_bound() << '\n';
upper_bound.set_include_down_tadpoles(true);
std::cout << "1-lp upper bound (all up squarks + all down squarks) = "
<< upper_bound.calculate_one_loop_upper_bound() << '\n';
upper_bound.set_include_exotic_tadpoles(true);
std::cout << "1-lp upper bound (3Su + 3Sd + 3SDX) = "
<< upper_bound.calculate_one_loop_upper_bound() << '\n';
upper_bound.set_include_inert_singlet_tadpoles(true);
std::cout << "1-lp upper bound (3Su + 3Sd + 3SDX + 3S) = "
<< upper_bound.calculate_one_loop_upper_bound() << '\n';
upper_bound.set_include_inert_neutral_higgs_tadpoles(true);
std::cout << "1-lp upper bound (3Su + 3Sd + 3SDX + 3S + 2HI0) = "
<< upper_bound.calculate_one_loop_upper_bound() << '\n';
upper_bound.set_include_inert_charged_higgs_tadpoles(true);
std::cout << "1-lp upper bound (3Su + 3Sd + 3SDX + 3S + 2HI0 + 2HIPM) = "
<< upper_bound.calculate_one_loop_upper_bound() << '\n';
double up_contribution = 0.;
double unrotated_up_00 = 0.;
double unrotated_up_01 = 0.;
double unrotated_up_11 = 0.;
double unrotated_down_00 = 0.;
double unrotated_down_01 = 0.;
double unrotated_down_11 = 0.;
double exotic_contribution = 0.;
double unrotated_exotic_00 = 0.;
double unrotated_exotic_01 = 0.;
double unrotated_exotic_11 = 0.;
for (unsigned gen = 0; gen < 3; ++gen) {
up_contribution += upper_bound.get_up_contribution(gen);
unrotated_up_00 += upper_bound.get_unrotated_up_contribution(gen, 0, 0);
unrotated_up_01 += upper_bound.get_unrotated_up_contribution(gen, 0, 1);
unrotated_up_11 += upper_bound.get_unrotated_up_contribution(gen, 1, 1);
unrotated_down_00 += upper_bound.get_unrotated_down_contribution(gen, 0, 0);
unrotated_down_01 += upper_bound.get_unrotated_down_contribution(gen, 0, 1);
unrotated_down_11 += upper_bound.get_unrotated_down_contribution(gen, 1, 1);
exotic_contribution += upper_bound.get_exotic_contribution(gen);
unrotated_exotic_00 += upper_bound.get_unrotated_exotic_contribution(gen, 0, 0);
unrotated_exotic_01 += upper_bound.get_unrotated_exotic_contribution(gen, 0, 1);
unrotated_exotic_11 += upper_bound.get_unrotated_exotic_contribution(gen, 1, 1);
}
std::cout << "up contribution to upper bound = "
<< up_contribution << '\n';
std::cout << "rotated 0p Su self-energy(0,0) = "
<< upper_bound.get_up_self_energy(0., 0, 0) << '\n';
std::cout << "unrotated up contribution (0,0) = "
<< unrotated_up_00 << '\n';
std::cout << "unrotated up contribution (0,1) = "
<< unrotated_up_01 << '\n';
std::cout << "unrotated up contribution (1,1) = "
<< unrotated_up_11 << '\n';
std::cout << "unrotated up 0p self-energy(0,0) = "
<< upper_bound.get_unrotated_up_self_energy(0., 0, 0) << '\n';
std::cout << "unrotated up 0p self-energy(0,1) = "
<< upper_bound.get_unrotated_up_self_energy(0., 0, 1) << '\n';
std::cout << "unrotated up 0p self-energy(1,1) = "
<< upper_bound.get_unrotated_up_self_energy(0., 1, 1) << '\n';
std::cout << "unrotated down contribution (0,0) = "
<< unrotated_down_00 << '\n';
std::cout << "unrotated down contribution (0,1) = "
<< unrotated_down_01 << '\n';
std::cout << "unrotated down contribution (1,1) = "
<< unrotated_down_11 << '\n';
std::cout << "unrotated down 0p self-energy(0,0) = "
<< upper_bound.get_unrotated_down_self_energy(0., 0, 0) << '\n';
std::cout << "unrotated down 0p self-energy(0,1) = "
<< upper_bound.get_unrotated_down_self_energy(0., 0, 1) << '\n';
std::cout << "unrotated down 0p self-energy(1,1) = "
<< upper_bound.get_unrotated_down_self_energy(0., 1, 1) << '\n';
std::cout << "unrotated exotic contribution (0,0) = "
<< unrotated_exotic_00 << '\n';
std::cout << "unrotated exotic contribution (0,1) = "
<< unrotated_exotic_01 << '\n';
std::cout << "unrotated exotic contribution (1,1) = "
<< unrotated_exotic_11 << '\n';
std::cout << "unrotated exotic 0p self-energy(0,0) = "
<< upper_bound.get_unrotated_exotic_self_energy(0., 0, 0) << '\n';
std::cout << "unrotated exotic 0p self-energy(0,1) = "
<< upper_bound.get_unrotated_exotic_self_energy(0., 0, 1) << '\n';
std::cout << "unrotated exotic 0p self-energy(1,1) = "
<< upper_bound.get_unrotated_exotic_self_energy(0., 1, 1) << '\n';
std::cout << "exotic contribution to upper bound = "
<< exotic_contribution << '\n';
std::cout << "rotated 0p SDX self-energy(0,0) = "
<< upper_bound.get_exotic_self_energy(0., 0, 0) << '\n';
std::cout << "unrotated Su self-energy (0,0) = "
<< upper_bound.get_unrotated_up_self_energy(model.get_Mhh()(0), 0, 0) << '\n';
std::cout << "unrotated Su self-energy (1,1) = "
<< upper_bound.get_unrotated_up_self_energy(model.get_Mhh()(0), 1, 1) << '\n';
std::cout << "unrotated SDX self-energy (0,0) = "
<< upper_bound.get_unrotated_exotic_self_energy(model.get_Mhh()(0), 0, 0) << '\n';
std::cout << "unrotated SDX self-energy (1,1) = "
<< upper_bound.get_unrotated_exotic_self_energy(model.get_Mhh()(0), 1, 1) << '\n';
std::cout << "unrotated self-energy (0,0) = "
<< upper_bound.get_unrotated_full_self_energy(model.get_Mhh()(0), 0, 0) << '\n';
std::cout << "unrotated self-energy (1,1) = "
<< upper_bound.get_unrotated_full_self_energy(model.get_Mhh()(0), 1, 1) << '\n';
std::cout << "full self-energy (1,1) element = "
<< upper_bound.get_full_self_energy(model.get_Mhh()(0), 0, 0) << '\n';
std::cout << "self-energy (1,1) element = "
<< upper_bound.get_self_energy(model.get_Mhh()(0), 0, 0) << '\n';
upper_bound.set_include_all_SM_generations(false);
upper_bound.set_include_up_tadpoles(false);
upper_bound.set_include_down_tadpoles(false);
upper_bound.set_include_exotic_tadpoles(true);
upper_bound.set_include_inert_singlet_tadpoles(false);
upper_bound.set_include_inert_neutral_higgs_tadpoles(false);
upper_bound.set_include_inert_charged_higgs_tadpoles(false);
std::cout << "t_1 = " << upper_bound.get_tadpole_vd() << '\n';
std::cout << "t_2 = " << upper_bound.get_tadpole_vu() << '\n';
std::cout << "tadpole contribution = " << (upper_bound.get_tadpole_vd() / model.get_vd())
* Sqr(Cos(ArcTan(model.get_vu() / model.get_vd()))) + (upper_bound.get_tadpole_vu() / model.get_vu())
* Sqr(Sin(ArcTan(model.get_vu() / model.get_vd()))) << '\n';
std::cout << "Delta_{11}^D = " << upper_bound.get_exotic_contribution(0) +
upper_bound.get_exotic_contribution(1) + upper_bound.get_exotic_contribution(2) << '\n';
std::cout << "sum = " << (upper_bound.get_tadpole_vd() / model.get_vd())
* Sqr(Cos(ArcTan(model.get_vu() / model.get_vd()))) + (upper_bound.get_tadpole_vu() / model.get_vu())
* Sqr(Sin(ArcTan(model.get_vu() / model.get_vd()))) + upper_bound.get_exotic_contribution(0) +
upper_bound.get_exotic_contribution(1) + upper_bound.get_exotic_contribution(2) << '\n';
upper_bound.set_include_all_SM_generations(false);
upper_bound.set_include_up_tadpoles(true);
upper_bound.set_include_down_tadpoles(false);
upper_bound.set_include_exotic_tadpoles(false);
upper_bound.set_include_inert_singlet_tadpoles(false);
upper_bound.set_include_inert_neutral_higgs_tadpoles(false);
upper_bound.set_include_inert_charged_higgs_tadpoles(false);
std::cout << "t_1 = " << upper_bound.get_tadpole_vd() << '\n';
std::cout << "t_2 = " << upper_bound.get_tadpole_vu() << '\n';
std::cout << "tadpole contribution = " << (upper_bound.get_tadpole_vd() / model.get_vd())
* Sqr(Cos(ArcTan(model.get_vu() / model.get_vd()))) + (upper_bound.get_tadpole_vu() / model.get_vu())
* Sqr(Sin(ArcTan(model.get_vu() / model.get_vd()))) << '\n';
std::cout << "Delta_{11}^D = " << upper_bound.get_up_contribution(2) << '\n';
std::cout << "sum = " << (upper_bound.get_tadpole_vd() / model.get_vd())
* Sqr(Cos(ArcTan(model.get_vu() / model.get_vd()))) + (upper_bound.get_tadpole_vu() / model.get_vu())
* Sqr(Sin(ArcTan(model.get_vu() / model.get_vd()))) + upper_bound.get_up_contribution(2) << '\n';
const int exit_code = spectrum_generator.get_exit_code();
return exit_code;
}
int main() {
/// Sets up exception handling
signal(SIGFPE, FPE_ExceptionHandler);
try {
/// Sets format of output: 6 decimal places
outputCharacteristics(6);
cerr << "SOFTSUSY" << SOFTSUSY_VERSION
<< " test program, Ben Allanach 2002\n";
cerr << "If you use SOFTSUSY, please refer to B.C. Allanach,\n";
cerr << "Comput. Phys. Commun. 143 (2002) 305, hep-ph/0104145\n";
/// Parameters used: CMSSM parameters
double m12 = 500., a0 = 0., mGutGuess = 2.0e16, tanb = 10.0, m0 = 125.;
int sgnMu = 1; ///< sign of mu parameter
int numPoints = 10; ///< number of scan points
QedQcd oneset; ///< See "lowe.h" for default definitions parameters
/// most important Standard Model inputs: you may change these and recompile
double alphasMZ = 0.1187, mtop = 173.5, mbmb = 4.18;
oneset.setAlpha(ALPHAS, alphasMZ);
oneset.setPoleMt(mtop);
oneset.setMbMb(mbmb);
oneset.toMz(); ///< Runs SM fermion masses to MZ
/// Print out the SM data being used, as well as quark mixing assumption and
/// the numerical accuracy of the solution
cout << "# Low energy data in SOFTSUSY: MIXING=" << MIXING << " TOLERANCE="
<< TOLERANCE << endl << oneset << endl;
/// Print out header line
cout << "# tan beta mh mA mH0 mH+-\n";
int i;
/// Set limits of tan beta scan
double startTanb = 3.0, endTanb = 50.0;
/// Cycle through different points in the scan
for (i = 0; i<=numPoints; i++) {
tanb = (endTanb - startTanb) / double(numPoints) * double(i) +
startTanb; // set tan beta ready for the scan.
/// Preparation for calculation: set up object and input parameters
MssmSoftsusy r;
DoubleVector pars(3);
pars(1) = m0; pars(2) = m12; pars(3) = a0;
bool uni = true; // MGUT defined by g1(MGUT)=g2(MGUT)
/// Calculate the spectrum
r.lowOrg(sugraBcs, mGutGuess, pars, sgnMu, tanb, oneset, uni);
/// check the point in question is problem free: if so print the output
if (!r.displayProblem().test())
cout << tanb << " " << r.displayPhys().mh0 << " "
<< r.displayPhys().mA0 << " "
<< r.displayPhys().mH0 << " "
<< r.displayPhys().mHpm << endl;
else
/// print out what the problem(s) is(are)
cout << tanb << " " << r.displayProblem() << endl;
}
}
catch(const string & a) { cout << a; }
catch(const char * a) { cout << a; }
catch(...) { cout << "Unknown type of exception caught.\n"; }
exit(0);
}
int main() {
/// Sets up exception handling
signal(SIGFPE, FPE_ExceptionHandler);
bool gaugeUnification = true, ewsbBCscale = false;
/// Do we include 2-loop RGEs of *all* scalar masses and A-terms, or only the
/// scalar mass Higgs parameters? (Other quantities all 2-loop anyway): the
/// default in SOFTSUSY 3 is to include all 2-loop terms, except for RPV,
/// which is already slow and calculated to less accuracy than the R-parity
/// conserving version
bool INCLUDE_2_LOOP_SCALAR_CORRECTIONS = false;
/// Sets format of output: 6 decimal places
outputCharacteristics(6);
/// Header
cerr << "SOFTSUSY" << SOFTSUSY_VERSION
<< " Ben Allanach, Markus Bernhardt 2009\n";
cerr << "If you use SOFTSUSY, please refer to B.C. Allanach, ";
cerr << "Comput. Phys. Commun. 143 (2002) 305, hep-ph/0104145;\n";
cerr << "For RPV aspects, B.C. Allanach and M.A. Bernhardt, ";
cerr << "Comp. Phys. Commun. 181 (2010) 232, ";
cerr << "arXiv:0903.1805.\n\n";
/// "try" catches errors in main program and prints them out
try {
/// Contains default quark and lepton masses and gauge coupling
/// information
QedQcd oneset; ///< See "lowe.h" for default parameter definitions
oneset.toMz(); ///< Runs SM fermion masses to MZ
/// Print out the Standard Model data being used, as well as quark mixing
/// assumption and the numerical accuracy of the solution
cerr << "Low energy data in SOFTSUSY: MIXING=" << MIXING << " TOLERANCE="
<< TOLERANCE << endl << oneset << endl;
/// set parameters
double tanb = 10.;
int sgnMu = 1;
double mgutGuess = 2.e16;
double a0 = -100.0, m12 = 250.0, m0 = 100.0;
/// number of points for scan
const int numPoints = 20;
/// parameter region
double Start = 0. , End = 0.144;
DoubleVector pars(3);
/// set basic entries in pars
pars(1) = m0; pars(2) = m12; pars(3) = a0;
cout << "l'_{331}(M_X) m_snutau # Problem flag" << endl;
/// loop over parameter space region
int ii; for (ii=0; ii<=numPoints; ii++){
double lambda = Start + ((End - Start) / double(numPoints) * double(ii));
/// define rpvSoftsusy object
RpvSoftsusy kw;
/// set lambda coupling at mgut
kw.setLamPrime(3, 3, 1, lambda);
/// output parameters into double vector pars used by lowOrg
kw.rpvDisplay(pars);
/// generate spectrum in RpvSoftsusy object kw
kw.lowOrg(rpvSugraBcs, mgutGuess, pars, sgnMu,
tanb, oneset, gaugeUnification, ewsbBCscale);
/// outputs for this scan
cout << lambda << " " << kw.displayPhys().msnu.display(3) << " # "
<< kw.displayProblem() << endl;
}
}
catch(const string & a) {
cout << a; exit(-1);
}
catch(const char *a) {
printf(a); exit(-1);
}
}
int main() {
/// Sets format of output: 6 decimal places
outputCharacteristics(6);
softsusy::PRINTOUT = 0;
/// Parameters used: CMSSM parameters
double m12 = 300., a0 = -300., mGutGuess = 2.0e16, tanb = 10.0, m0 = 500.;
int sgnMu = 1; ///< sign of mu parameter
int numPoints = 10; ///< number of scan points
double lambda = 0.1, kappa = 0.1, s = 0.0, xiF = 0.0, mupr = 0.0;
QedQcd oneset; ///< See "lowe.h" for default definitions parameters
/// most important Standard Model inputs: you may change these and recompile
double alphasMZ = 0.1187, mtop = 173.5, mbmb = 4.18;
oneset.setAlpha(ALPHAS, alphasMZ);
oneset.setPoleMt(mtop);
oneset.setMass(mBottom, mbmb);
oneset.toMz(); ///< Runs SM fermion masses to MZ
/// Print out the SM data being used, as well as quark mixing assumption and
/// the numerical accuracy of the solution
cout << "# Low energy data in SOFTSUSY: MIXING=" << MIXING << " TOLERANCE="
<< TOLERANCE << endl << oneset << endl;
/// Print out header line
cout << "# tan beta mh(1) mh(2) mA(1) mA(2)"
<< " mH+-\n";
/// Set limits of tan beta scan
double startTanb = 5.0, endTanb = 55.0;
DoubleVector pars(5);
pars(1) = m0; pars(2) = m12; pars(3) = a0;
pars(4) = a0, pars(5) = a0;
DoubleVector nmpars(5);
nmpars(1) = lambda; nmpars(2) = kappa; nmpars(3) = s;
nmpars(4) = xiF; nmpars(5) = mupr;
bool uni = true; // MGUT defined by g1(MGUT)=g2(MGUT)
softsusy::Z3 = true;
for (int i = 0; i < numPoints; i++) {
tanb = (endTanb - startTanb) / double(numPoints) * double(i) +
startTanb; // set tan beta ready for the scan.
NmssmSoftsusy n;
try {
n.NmssmSoftsusy::lowOrg(SemiMsugraBcs, mGutGuess, pars, nmpars,
sgnMu, tanb, oneset, uni);
} catch (const std::string& error) {
n.flagProblemThrown(true);
} catch (const char* error) {
n.flagProblemThrown(true);
}
/// check the point in question is problem free: if so print the output
if (!n.displayProblem().test()) {
cout << tanb << ' '
<< n.displayPhys().mh0(1) << ' '
<< n.displayPhys().mh0(2) << ' '
<< n.displayPhys().mA0(1) << ' '
<< n.displayPhys().mA0(2) << ' '
<< n.displayPhys().mHpm << '\n';
} else {
cout << tanb << ' ' << n.displayProblem() << '\n';
}
}
return 0;
}
int main(int argc, const char * argv[])
{
typedef Two_scale algorithm_type;
Command_line_options options(argc, argv);
if (options.must_print_model_info())
CNE6SSM_info::print(std::cout);
if (options.must_exit())
return options.status();
const std::string rgflow_file(options.get_rgflow_file());
const std::string slha_input_file(options.get_slha_input_file());
const std::string slha_output_file(options.get_slha_output_file());
const std::string spectrum_file(options.get_spectrum_file());
CNE6SSM_slha_io slha_io;
Spectrum_generator_settings spectrum_generator_settings;
QedQcd oneset;
CNE6SSM_input_parameters<Two_scale> input;
if (slha_input_file.empty()) {
ERROR("No SLHA input file given!\n"
" Please provide one via the option --slha-input-file=");
return EXIT_FAILURE;
}
try {
slha_io.read_from_file(slha_input_file);
slha_io.fill(oneset);
slha_io.fill(input);
slha_io.fill(spectrum_generator_settings);
} catch (const Error& error) {
ERROR(error.what());
return EXIT_FAILURE;
}
oneset.toMz(); // run SM fermion masses to MZ
CNE6SSM_spectrum_generator<algorithm_type> spectrum_generator;
spectrum_generator.set_precision_goal(
spectrum_generator_settings.get(Spectrum_generator_settings::precision));
spectrum_generator.set_max_iterations(
spectrum_generator_settings.get(Spectrum_generator_settings::max_iterations));
spectrum_generator.set_calculate_sm_masses(
spectrum_generator_settings.get(Spectrum_generator_settings::calculate_sm_masses) >= 1.0);
spectrum_generator.set_force_output(
spectrum_generator_settings.get(Spectrum_generator_settings::force_output) >= 1.0);
spectrum_generator.set_parameter_output_scale(
slha_io.get_parameter_output_scale());
spectrum_generator.set_pole_mass_loop_order(
spectrum_generator_settings.get(Spectrum_generator_settings::pole_mass_loop_order));
spectrum_generator.set_ewsb_loop_order(
spectrum_generator_settings.get(Spectrum_generator_settings::ewsb_loop_order));
spectrum_generator.set_beta_loop_order(
spectrum_generator_settings.get(Spectrum_generator_settings::beta_loop_order));
spectrum_generator.set_threshold_corrections_loop_order(
spectrum_generator_settings.get(Spectrum_generator_settings::threshold_corrections_loop_order));
spectrum_generator.set_two_loop_corrections(
spectrum_generator_settings.get_two_loop_corrections());
spectrum_generator.run(oneset, input);
const CNE6SSM<algorithm_type>& model
= spectrum_generator.get_model();
const Problems<CNE6SSM_info::NUMBER_OF_PARTICLES>& problems
= spectrum_generator.get_problems();
// output
slha_io.set_spinfo(problems);
slha_io.set_sminputs(oneset);
slha_io.set_minpar(input);
slha_io.set_extpar(input);
if (!problems.have_problem())
slha_io.set_spectrum(model);
if (!slha_output_file.empty()) {
slha_io.write_to_file(slha_output_file);
}
if (!spectrum_file.empty())
spectrum_generator.write_spectrum(spectrum_file);
if (!rgflow_file.empty())
spectrum_generator.write_running_couplings(rgflow_file);
const int exit_code = spectrum_generator.get_exit_code();
// if point is valid, calculate coefficients in RG running
if (exit_code == EXIT_SUCCESS) {
// soft scalar masses to calculate coefficients for
std::vector<CNE6SSM_info::Parameters> soft_scalar_masses
= {CNE6SSM_info::mHd2, CNE6SSM_info::mHu2, CNE6SSM_info::ms2,
CNE6SSM_info::msbar2, CNE6SSM_info::mphi2, CNE6SSM_info::mq200,
CNE6SSM_info::mu200};
// soft gaugino masses to calculate coefficients for
std::vector<CNE6SSM_info::Parameters> soft_gaugino_masses
= {CNE6SSM_info::MassB, CNE6SSM_info::MassWB, CNE6SSM_info::MassG,
CNE6SSM_info::MassBp};
// soft trilinears to calculate coefficients for
std::vector<CNE6SSM_info::Parameters> soft_trilinears
= {CNE6SSM_info::TYu22, CNE6SSM_info::TYu00, CNE6SSM_info::TSigmax,
CNE6SSM_info::TLambdax};
double aLambdax = 0.;
double bLambdax = 0.;
double cLambdax = 0.;
double dLambdax = 0.;
double lLambdax = 0.;
double tree_level_Lambdax = 0.;
double aMu2 = 0.;
double bMu2 = 0.;
double cMu2 = 0.;
double dMu2 = 0.;
double lMu2 = 0.;
bool is_calculating_mHd2_coeffs = false;
bool is_calculating_mHu2_coeffs = false;
bool can_calculate_Lambdax_coeffs = false;
for (std::size_t i = 0; i < soft_scalar_masses.size(); ++i) {
if (soft_scalar_masses[i] == CNE6SSM_info::mHd2) {
is_calculating_mHd2_coeffs = true;
} else if (soft_scalar_masses[i] == CNE6SSM_info::mHu2) {
is_calculating_mHu2_coeffs = true;
}
if (is_calculating_mHd2_coeffs && is_calculating_mHu2_coeffs) {
can_calculate_Lambdax_coeffs = true;
break;
}
}
// get high scale
double high_scale = spectrum_generator.get_high_scale();
// get SUSY scale - this will be fixed scale
// for comparison at
double susy_scale = spectrum_generator.get_susy_scale();
// calculate coefficients and percentage errors the original way
std::map<CNE6SSM_info::Parameters, std::vector<double> > soft_scalar_mass_coeffs;
std::map<CNE6SSM_info::Parameters, double> soft_scalar_mass_errors;
for (std::vector<CNE6SSM_info::Parameters>::const_iterator it = soft_scalar_masses.begin(),
end = soft_scalar_masses.end(); it != end; ++it) {
const Eigen::Array<double,4,1> coeffs = model.get_soft_scalar_mass_coeffs(*it, susy_scale, high_scale);
soft_scalar_mass_coeffs[*it] = {coeffs(0), coeffs(1), coeffs(2), coeffs(3)};
const double pred_value = coeffs(0) * Sqr(input.m0) + coeffs(1) * Sqr(input.m12)
+ coeffs(2) * input.m12 * input.Azero + coeffs(3) * Sqr(input.Azero);
soft_scalar_mass_errors[*it] = 100.0 * Abs((model.get_parameter(*it) - pred_value) /
(0.5 * (model.get_parameter(*it) + pred_value)));
}
std::map<CNE6SSM_info::Parameters, std::vector<double> > soft_gaugino_mass_coeffs;
std::map<CNE6SSM_info::Parameters, double> soft_gaugino_mass_errors;
for (std::vector<CNE6SSM_info::Parameters>::const_iterator it = soft_gaugino_masses.begin(),
end = soft_gaugino_masses.end(); it != end; ++it) {
const Eigen::Array<double,2,1> coeffs = model.get_soft_gaugino_mass_coeffs(*it, susy_scale, high_scale);
soft_gaugino_mass_coeffs[*it] = {coeffs(0), coeffs(1)};
const double pred_value = coeffs(0) * input.Azero + coeffs(1) * input.m12;
soft_gaugino_mass_errors[*it] = 100.0 * Abs((model.get_parameter(*it) - pred_value) /
(0.5 * (model.get_parameter(*it) + pred_value)));
}
std::map<CNE6SSM_info::Parameters, std::vector<double> > soft_trilinear_coeffs;
std::map<CNE6SSM_info::Parameters, double> soft_trilinear_errors;
for (std::vector<CNE6SSM_info::Parameters>::const_iterator it = soft_trilinears.begin(),
end = soft_trilinears.end(); it != end; ++it) {
const Eigen::Array<double,2,1> coeffs = model.get_soft_trilinear_coeffs(*it, susy_scale, high_scale);
soft_trilinear_coeffs[*it] = {coeffs(0), coeffs(1)};
const double pred_value = coeffs(0) * input.Azero + coeffs(1) * input.m12;
soft_trilinear_errors[*it] = 100.0 * Abs((model.get_parameter(*it) - pred_value) /
(0.5 * (model.get_parameter(*it) + pred_value)));
}
CNE6SSM<algorithm_type> running_model(model);
running_model.run_to(high_scale);
if (can_calculate_Lambdax_coeffs) {
aLambdax = get_tree_level_Lambdax_soft_term(model, soft_scalar_mass_coeffs[CNE6SSM_info::mHd2][0],
soft_scalar_mass_coeffs[CNE6SSM_info::mHu2][0]);
bLambdax = get_tree_level_Lambdax_soft_term(model, soft_scalar_mass_coeffs[CNE6SSM_info::mHd2][1],
soft_scalar_mass_coeffs[CNE6SSM_info::mHu2][1]);
cLambdax = get_tree_level_Lambdax_soft_term(model, soft_scalar_mass_coeffs[CNE6SSM_info::mHd2][2],
soft_scalar_mass_coeffs[CNE6SSM_info::mHu2][2]);
dLambdax = get_tree_level_Lambdax_soft_term(model, soft_scalar_mass_coeffs[CNE6SSM_info::mHd2][3],
soft_scalar_mass_coeffs[CNE6SSM_info::mHu2][3]);
lLambdax = get_tree_level_Lambdax_constant_term(model);
running_model.run_to(susy_scale);
running_model.solve_ewsb_tree_level();
tree_level_Lambdax = running_model.get_Lambdax();
aMu2 = get_tree_level_MuSq_soft_term(model, soft_scalar_mass_coeffs[CNE6SSM_info::mHd2][0],
soft_scalar_mass_coeffs[CNE6SSM_info::mHu2][0]);
bMu2 = get_tree_level_MuSq_soft_term(model, soft_scalar_mass_coeffs[CNE6SSM_info::mHd2][1],
soft_scalar_mass_coeffs[CNE6SSM_info::mHu2][1]);
cMu2 = get_tree_level_MuSq_soft_term(model, soft_scalar_mass_coeffs[CNE6SSM_info::mHd2][2],
soft_scalar_mass_coeffs[CNE6SSM_info::mHu2][2]);
dMu2 = get_tree_level_MuSq_soft_term(model, soft_scalar_mass_coeffs[CNE6SSM_info::mHd2][3],
soft_scalar_mass_coeffs[CNE6SSM_info::mHu2][3]);
lMu2 = get_tree_level_MuSq_constant_term(model);
}
// print results
std::cout << "Coefficients for requested parameters:\n";
for (std::vector<CNE6SSM_info::Parameters>::const_iterator it = soft_scalar_masses.begin(),
end = soft_scalar_masses.end(); it != end; ++it) {
std::cout << "a(" << CNE6SSM_info::parameter_names[*it]
<< ", " << susy_scale << " GeV) = " << soft_scalar_mass_coeffs[*it][0] << "\n";
std::cout << "b(" << CNE6SSM_info::parameter_names[*it]
<< ", " << susy_scale << " GeV) = " << soft_scalar_mass_coeffs[*it][1] << "\n";
std::cout << "c(" << CNE6SSM_info::parameter_names[*it]
<< ", " << susy_scale << " GeV) = " << soft_scalar_mass_coeffs[*it][2] << "\n";
std::cout << "d(" << CNE6SSM_info::parameter_names[*it]
<< ", " << susy_scale << " GeV) = " << soft_scalar_mass_coeffs[*it][3] << "\n";
std::cout << "% error = " << soft_scalar_mass_errors[*it] << "\n";
}
for (std::vector<CNE6SSM_info::Parameters>::const_iterator it = soft_gaugino_masses.begin(),
end = soft_gaugino_masses.end(); it != end; ++it) {
std::cout << "p(" << CNE6SSM_info::parameter_names[*it]
<< ", " << susy_scale << " GeV) = " << soft_gaugino_mass_coeffs[*it][0] << "\n";
std::cout << "q(" << CNE6SSM_info::parameter_names[*it]
<< ", " << susy_scale << " GeV) = " << soft_gaugino_mass_coeffs[*it][1] << "\n";
std::cout << "% error = " << soft_scalar_mass_errors[*it] << "\n";
}
for (std::vector<CNE6SSM_info::Parameters>::const_iterator it = soft_trilinears.begin(),
end = soft_trilinears.end(); it != end; ++it) {
std::cout << "e(" << CNE6SSM_info::parameter_names[*it]
<< ", " << susy_scale << " GeV) = " << soft_trilinear_coeffs[*it][0] << "\n";
std::cout << "f(" << CNE6SSM_info::parameter_names[*it]
<< ", " << susy_scale << " GeV) = " << soft_trilinear_coeffs[*it][1] << "\n";
std::cout << "% error = " << soft_trilinear_errors[*it] << "\n";
}
if (can_calculate_Lambdax_coeffs) {
std::cout << "a(Lambdax^2, " << susy_scale << " GeV) = " << aLambdax << "\n";
std::cout << "b(Lambdax^2, " << susy_scale << " GeV) = " << bLambdax << "\n";
std::cout << "c(Lambdax^2, " << susy_scale << " GeV) = " << cLambdax << "\n";
std::cout << "d(Lambdax^2, " << susy_scale << " GeV) = " << dLambdax << "\n";
std::cout << "l(Lambdax^2, " << susy_scale << " GeV) = " << lLambdax << "\n";
std::cout << "a(Mueff^2, " << susy_scale << " GeV) = " << aMu2 << "\n";
std::cout << "b(Mueff^2, " << susy_scale << " GeV) = " << bMu2 << "\n";
std::cout << "c(Mueff^2, " << susy_scale << " GeV) = " << cMu2 << "\n";
std::cout << "d(Mueff^2, " << susy_scale << " GeV) = " << dMu2 << "\n";
std::cout << "l(Mueff^2, " << susy_scale << " GeV) = " << lMu2 << "\n";
std::cout << "Lambdax 0lp = " << tree_level_Lambdax << "\n";
std::cout << "Coeffs sum = " << input.SignLambdax *
Sqrt(aLambdax * Sqr(model.get_input().m0) + bLambdax * Sqr(model.get_input().m12)
+ cLambdax * model.get_input().m12 * model.get_input().Azero + dLambdax * Sqr(model.get_input().Azero)
+ lLambdax) << "\n";
}
Eigen::Matrix<std::complex<double>,8,8> ZN = model.get_ZN();
std::cout << "Higgsino = " << Sqr(std::real(ZN(2,0))) + Sqr(std::imag(ZN(2,0))) + Sqr(std::real(ZN(3,0)))
+ Sqr(std::imag(ZN(3,0))) << "\n";
std::cout << "Bino = " << Sqr(std::real(ZN(0,0))) + Sqr(std::imag(ZN(0,0))) << "\n";
}
return exit_code;
}
