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;
}
예제 #2
0
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);
  }
}
예제 #3
0
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;
}
예제 #5
0
파일: main.cpp 프로젝트: xueweiphy/superpy
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);
}
예제 #6
0
파일: rpvmain.cpp 프로젝트: crsilk/UserCode
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);
  }
  
}
예제 #7
0
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;
}