int main(int argc, char *argv[]) {
int numPoints = 1;
double qMax = 0.;
// Sets format of output: 4 decimal places
outputCharacteristics(6);
void (*boundaryCondition)(MssmSoftsusy &, const DoubleVector &);
if (argc !=1 ) {
cerr << "GAUGE/GRAVITY" << endl;
cerr << "SOFTSUSY" << VERSION << endl;
cerr << "B.C. Allanach, Comput. Phys. Commun. 143 (2002) 305-331,";
cerr << " hep-ph/0104145\n";
cerr << "Low energy data in SOFTSUSY: MIXING=" << MIXING << " TOLERANCE="
<< TOLERANCE << endl;
cerr << "G_F=" << GMU << " GeV^2" << endl;
}
// RANDOM SEED /////////////////////
time_t seconds;
time( &seconds);
srand( (unsigned int) seconds );
////////////////////////////////////
double mgutGuess = 2.0e16, mbmb = MBOTTOM, mtau = MTAU;
int sgnMu = 1;
bool gaugeUnification = false, ewsbBCscale = false, altEwsb = false;
bool flag = false;
double M_moduli_start, M_moduli_end ;
double M_gauge_start, M_gauge_end ;
double M_mess_start, M_mess_end ;
double M_moduli, M_gauge, M_mess ;
double tanb_start, tanb_end ;
double tanb = 10;
DoubleVector pars(3);
// My modification
cout << "argc = " << argc << endl;
cout << flush ;
if(argc != 3 ) {
errorCall() ;
exit(-1) ;
}
/* if (!strcmp(argv[1], "g-gmsb")) {
cout << "SOFTSUSY Gauge/Gravity calculation" << endl;
cout << flush; */
if( argc == 3 ) {
ifstream inputfile(argv[1]);
ofstream outputfile(argv[2]);
string varname;
inputfile >> varname >> l1 ;
cout << varname << endl;
inputfile >> varname >> l2 ;
inputfile >> varname >> l3 ;
inputfile >> varname >> nQ ;
inputfile >> varname >> nU ;
inputfile >> varname >> nD ;
inputfile >> varname >> nL ;
inputfile >> varname >> nE ;
inputfile >> varname >> nHu ;
inputfile >> varname >> nHd ;
inputfile >> varname >> N ;
inputfile >> varname >> numscan;
inputfile >> varname >> M_moduli_start ;
inputfile >> varname >> M_moduli_end ;
inputfile >> varname >> M_gauge_start ;
inputfile >> varname >> M_gauge_end ;
inputfile >> varname >> M_mess_start ;
inputfile >> varname >> M_mess_end ;
inputfile >> varname >> tanb_start ;
inputfile >> varname >> tanb_end ;
inputfile >> varname >> sgnMu ;
inputfile.close();
cout << "l1 = " << l1 << endl
<< "l2 = " << l2 << endl
<< "l3 = " << l3 << endl
<< "nQ = " << nQ << endl
<< "nU = " << nU << endl
<< "nD = " << nD << endl
<< "nL = " << nL << endl
<< "nE = " << nE << endl
<< "nHu = " << nHu << endl
<< "nHd = " << nHd << endl
<< "N = " << N << endl
<< "numscan = " << numscan << endl
<< "M_moduli_start = " << M_moduli_start << endl
<< "M_moduli_end = " << M_moduli_end << endl
<< "M_gauge_start = " << M_gauge_start << endl
<< "M_gauge_end = " << M_gauge_end << endl
<< "M_mess_start = " << M_mess_start << endl
<< "M_mess_end = " << M_mess_end << endl
<< "tanb_start = " << tanb_start << endl
<< "tanb_end = " << tanb_end << endl
<< "sgnMu = " << sgnMu << endl;
for( int i = 0 ; i < numscan ; i++ ) {
QedQcd oneset0, oneset1, oneset2;
M_moduli = randomgenerator( M_moduli_start, M_moduli_end ) ;
M_gauge = randomgenerator( M_gauge_start, M_gauge_end ) ;
M_mess = lograndomgenerator( M_mess_start, M_mess_end ) ;
tanb = randomgenerator( tanb_start, tanb_end ) ;
cout << i << "th run : " << endl ;
cout << "M_moduli = " << M_moduli << endl
<< "M_gauge = " << M_gauge << endl
<< "M_mess = " << M_mess << endl
<< "tanb = " << tanb << endl ;
mgutGuess = 2e16;
gaugeUnification = false;
pars.setEnd(3);
pars(1) = M_moduli; pars(2) = M_gauge; pars(3) = M_mess;
// r = &m;
// if (flag) oneset0.calcPoleMb();
oneset0.toMz();
oneset1.toMz();
oneset2.toMz();
// ofstream rgefile;
// rgefile.open("rge.dat");
// ofstream spectrumfile;
// spectrumfile.open("spectrum.dat") ;
// cout << "Here comes r1 " << endl;
MssmSoftsusy r0 ;
cout << "Starting" << endl;
r0.N= 0 ;
r0.Nflag = true;
r0.beta2() ;
r0.Nflag = false;
double mgut = r0.lowOrg(gaugegravityBcs0, mgutGuess, pars, sgnMu,
tanb, oneset0, gaugeUnification, ewsbBCscale);
r0.runto( M_mess );
cout << "starting phase 2 " << endl;
r0.N = N ;
r0.Nflag = true;
r0.beta2() ;
r0.Nflag = false;
r0.runto( mgutGuess ) ;
global_g1 = r0.displayGaugeCoupling(1);
global_g2 = r0.displayGaugeCoupling(2);
global_g3 = r0.displayGaugeCoupling(3);
MssmSoftsusy r1 ; //, r2;// MssmSoftsusy2 l;
r1.N = N ;
r1.Nflag = true;
r1.beta2();
r1.Nflag = false ;
mgut = r1.lowOrg(gaugegravityBcs1, mgutGuess, pars, sgnMu,
tanb, oneset1, gaugeUnification, ewsbBCscale);
cout << "Here comes r1" << endl;
cout << r1 ;
// RGRUN( rgefile, r1 , log(mgutGuess) / log(10) , log( M_mess) / log( 10 ) , 20 ) ;
r1.runto( M_mess );
global_g1 = r1.displayGaugeCoupling(1);
global_g2 = r1.displayGaugeCoupling(2);
global_g3 = r1.displayGaugeCoupling(3);
inter_gaugino1 = r1.displayGaugino(1);
inter_gaugino2 = r1.displayGaugino(2);
inter_gaugino3 = r1.displayGaugino(3);
inter_massmQl = r1.displaySoftMassSquared(mQl) ;
inter_massmUr = r1.displaySoftMassSquared(mUr) ;
inter_massmDr = r1.displaySoftMassSquared(mDr) ;
inter_massmLl = r1.displaySoftMassSquared(mLl) ;
inter_massmEr = r1.displaySoftMassSquared(mEr) ;
inter_massmHu = r1.displayMh2Squared();
inter_massmHd = r1.displayMh1Squared();
inter_A_HuQU(1,1) = r1.displaySoftA( UA, 1, 1);
inter_A_HuQU(2,2) = r1.displaySoftA( UA, 2, 2);
inter_A_HuQU(3,3) = r1.displaySoftA( UA, 3, 3);
inter_A_HdQD(1,1) = r1.displaySoftA( DA, 1, 1);
inter_A_HdQD(2,2) = r1.displaySoftA( DA, 2, 2);
inter_A_HdQD(3,3) = r1.displaySoftA( DA, 3, 3);
inter_A_HdLE(1,1) = r1.displaySoftA( EA, 1, 1);
inter_A_HdLE(2,2) = r1.displaySoftA( EA, 2, 2);
inter_A_HdLE(3,3) = r1.displaySoftA( EA, 3, 3);
mgutGuess = M_mess ;
cout << "Here comes r2" << endl;
MssmSoftsusy r2 ;
r2.N = 0;
r2.Nflag = true;
r2.beta2();
r2.Nflag = false ;
mgut = r2.lowOrg(gaugegravityBcs2, mgutGuess, pars, sgnMu,
tanb, oneset2, gaugeUnification, ewsbBCscale);
// cout << r2 ;
// RGRUN( rgefile, r2 , log(M_mess) / log(10), log(100) / log(10), 20 ) ;
//rgefile.close();
//spectrumrecord( spectrumfile, r2 ) ;
// spectrumfile.close();
cout << r2 ;
// sPhysical p = r2.displayPhys() ;
// cout << p ;
ofstream tempfile("LesHouches.dat");
streambuf* strm_buffer = cout.rdbuf();
cout.rdbuf( tempfile.rdbuf() ) ;
r2.lesHouchesAccordOutput("nonUniversal", pars,
sgnMu, tanb, 0, 1, mbmb,
mtau, MGUTSCALE , 0 ) ;
cout << flush;
cout.rdbuf(strm_buffer);
tempfile.close();
if (r2.displayProblem().test()) {
cout << "# SOFTSUSY problem with point: " << r2.displayProblem();
}
if( checktheresult( r2 ) ) {
//////////////////////////////////////////////////
// micrOmegas //
//////////////////////////////////////////////////
double Xf, Omega, Omega2, bsg_value, bsmumu_value, gmuon_value;
string mess;
double mtop ;
int err ;
int fast = 1;
double Beps = 1E-6 ;
double cut = 0.01;
err = readLesH("LesHouches.dat",1);
//
// printVar(stdout);
//
char messtemp[20];
err=sortOddParticles(messtemp);
mess = messtemp;
// HiggsMasses(stdout);
// printMasses(stdout,1);
Omega=darkOmega(&Xf,fast,Beps);
o1Contents(stdout);
printChannels(Xf,cut,Beps,1,stdout);
bsg_value= bsgnlo_();
bsmumu_value = bsmumu_();
gmuon_value = gmuon_();
recordphysics( outputfile, r2, M_moduli, M_gauge, M_mess, tanb,
bsg_value, gmuon_value, bsmumu_value, Omega ) ;
}
else {
recordphysics( outputfile, r2, M_moduli, M_gauge, M_mess, tanb,
0, 0 , 0, 0 ) ;
}
}
}
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() {
/// 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() {
/// 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);
}
}
