struct key_lookup_table
{
int code;
const char *name;
};
#define KE(x) { SDL_SCANCODE_ ## x, "SDL_SCANCODE_" #x },
#define KE8(A, B, C, D, E, F, G, H) KE(A) KE(B) KE(C) KE(D) KE(E) KE(F) KE(G) KE(H)
#define KE7(A, B, C, D, E, F, G) KE(A) KE(B) KE(C) KE(D) KE(E) KE(F) KE(G)
#define KE5(A, B, C, D, E) KE(A) KE(B) KE(C) KE(D) KE(E)
#define KE3(A, B, C) KE(A) KE(B) KE(C)
static key_lookup_table sdl_lookup_table[] =
{
KE7(UNKNOWN, BACKSPACE, TAB, CLEAR, RETURN, PAUSE, ESCAPE)
KE(SPACE)
KE5(COMMA, MINUS, PERIOD, SLASH, 0)
KE8(1, 2, 3, 4, 5, 6, 7, 8)
KE3(9, SEMICOLON, EQUALS)
KE5(LEFTBRACKET,BACKSLASH, RIGHTBRACKET, A, B)
KE8(C, D, E, F, G, H, I, J)
KE8(K, L, M, N, O, P, Q, R)
KE8(S, T, U, V, W, X, Y, Z)
KE8(DELETE, KP_0, KP_1, KP_2, KP_3, KP_4, KP_5, KP_6)
KE8(KP_7, KP_8, KP_9, KP_PERIOD, KP_DIVIDE, KP_MULTIPLY,KP_MINUS, KP_PLUS)
KE8(KP_ENTER, KP_EQUALS, UP, DOWN, RIGHT, LEFT, INSERT, HOME)
KE8(END, PAGEUP, PAGEDOWN, F1, F2, F3, F4, F5)
KE8(F6, F7, F8, F9, F10, F11, F12, F13)
KE8(F14, F15, NUMLOCKCLEAR, CAPSLOCK, SCROLLLOCK, RSHIFT, LSHIFT, RCTRL)
KE5(LCTRL, RALT, LALT, LGUI, RGUI)
KE8(GRAVE, LEFTBRACKET,RIGHTBRACKET, SEMICOLON, APOSTROPHE, BACKSLASH, PRINTSCREEN,MENU)
void InitSLState(
const dTensorBC4& q, const dTensorBC4& aux, SL_state& sl_state )
{
void ComputeElecField(double t, const dTensor2& node1d,
const dTensorBC4& qvals, dTensorBC3& Evals);
void ConvertQ2dToQ1d(const int &mopt, int istart, int iend,
const dTensorBC4& qin, dTensorBC3& qout);
void IntegrateQ1dMoment1(const dTensorBC4& q2d, dTensorBC3& q1d);
const int space_order = dogParams.get_space_order();
const int mx = q.getsize(1);
const int my = q.getsize(2);
const int meqn = q.getsize(3);
const int maux = aux.getsize(2);
const int kmax = q.getsize(4);
const int mbc = q.getmbc();
const int mpoints = space_order*space_order;
const int kmax1d = space_order;
const double tn = sl_state.tn;
//////////////////////// Compute Electric Field E(t) ////////////////////
// save 1d grid points ( this is used for poisson solve )
dTensorBC3 Enow(mx, meqn, kmax1d, mbc, 1);
ComputeElecField( tn, *sl_state.node1d, *sl_state.qnew, Enow);
//////////// Necessary terms for Et = -M1 + g(x,t) /////////////////////
dTensorBC3 M1(mx, meqn, kmax1d,mbc,1);
IntegrateQ1dMoment1(q, M1); // first moment
//////////// Necessary terms for Ett = 2*KE_x - rho*E + g_t - psi_u ///////
dTensorBC3 KE(mx, meqn, kmax1d,mbc,1);
void IntegrateQ1dMoment2(const dTensorBC4& q2d, dTensorBC3& q1d);
IntegrateQ1dMoment2(q, KE); // 1/2 * \int v^2 * f dv //
SetBndValues1D( KE );
SetBndValues1D( Enow );
SetBndValues1D( M1 );
// do something to compute KE_x ... //
dTensorBC3 gradKE(mx,2,kmax1d,mbc,1);
FiniteDiff( 1, 2, KE, gradKE ); // compute KE_x and KE_xx //
dTensorBC3 rho(mx,meqn,kmax1d,mbc,1);
dTensorBC3 prod(mx,meqn,kmax1d,mbc,1);
void IntegrateQ1d(const int mopt, const dTensorBC4& q2d, dTensorBC3& q1d);
void MultiplyFunctions(const dTensorBC3& Q1, const dTensorBC3& Q2,
dTensorBC3& qnew);
IntegrateQ1d( 1, q, rho );
MultiplyFunctions( rho, Enow, prod );
/////////////////////// Save E, Et, Ett, //////////////////////////////////
for( int i = 1; i <= mx; i++ )
for( int k = 1; k <= kmax1d; k ++ )
{
double E = Enow.get ( i, 1, k );
double Et = -M1.get ( i, 1, k ); // + g(x,t)
double Ett = -prod.get(i,1,k) + 2.0*gradKE.get(i,1,k); // + others //
sl_state.aux1d->set(i,2,1, k, E );
sl_state.aux1d->set(i,2,2, k, Et );
sl_state.aux1d->set(i,2,3, k, Ett );
}
///////////////////////////////////////////////////////////////////////////
// terms used for 4th order stuff ... //
// Ettt = -M3_xx + (2*E_x+rho)*M1 + 3*E*(M1)_x
dTensorBC3 tmp0(mx,2*meqn,kmax1d,mbc,1);
dTensorBC3 tmp1(mx,meqn,kmax1d,mbc,1);
// compute the third moment and its 2nd derivative
dTensorBC3 M3 (mx,meqn,kmax1d,mbc,1);
dTensorBC3 M3_x (mx,2*meqn,kmax1d,mbc,1);
void IntegrateQ1dMoment3(const dTensorBC4& q2d, dTensorBC3& q1d);
IntegrateQ1dMoment3(q, M3 );
SetBndValues1D( M3 );
FiniteDiff( 1, 2, M3, M3_x );
// Compute 2*Ex+rho //
FiniteDiff(1, 2*meqn, Enow, tmp0);
for( int i=1; i <= mx; i++ )
for( int k=1; k <= kmax1d; k++ )
{ tmp1.set(i,1,k, 2.0*tmp0.get(i,1,k) + rho.get(i,1,k) ); }
// compute (2Ex+rho) * M1
dTensorBC3 prod1(mx,meqn,kmax1d,mbc,1);
MultiplyFunctions( tmp1, M1, prod1 );
// compute M1_x and M1_xx
dTensorBC3 M1_x (mx,2*meqn,kmax1d,mbc,1);
FiniteDiff( 1, 2, M1, M1_x );
//compute 3*M1_x and E * (3*M1)_x
dTensorBC3 prod2(mx,meqn,kmax1d,mbc,1);
for( int i=1; i <= mx; i++ )
for( int k=1; k <= kmax1d; k++ )
{ tmp1.set(i, 1, k, 3.0*M1_x.get(i, 1, k) ); }
MultiplyFunctions( Enow, tmp1, prod2 );
/////////////////////// Save Ettt /////////////////////////////////////////
for( int i = 1; i <= mx; i++ )
for( int k = 1; k <= kmax1d; k ++ )
{
double Ettt = -M3_x.get(i,2,k) + prod1.get(i,1,k) + prod2.get(i,1,k);
sl_state.aux1d->set(i,2,4, k, Ettt );
}
///////////////////////////////////////////////////////////////////////////
if ( dogParams.get_source_term()>0 )
{
double* t_ptr = new double;
*t_ptr = tn;
// 2D Electric field, and 1D Electric Field
dTensorBC4* ExactE;
ExactE = new dTensorBC4(mx,1,4,kmax,mbc);
dTensorBC3* ExactE1d;
ExactE1d = new dTensorBC3(mx,4,kmax1d,mbc,1);
// Extra Source terms needed for the electric field
dTensorBC4* ExtraE;
ExtraE = new dTensorBC4(mx,1,4,kmax,mbc);
dTensorBC3* ExtraE1d;
ExtraE1d = new dTensorBC3(mx,4,kmax1d,mbc,1);
// Exact, electric field: (TODO - REMOVE THIS!)
// void ElectricField(const dTensor2& xpts, dTensor2& e, void* data);
// L2Project_extra(1-mbc, mx+mbc, 1, 1, space_order, -1, ExactE,
// &ElectricField, (void*)t_ptr );
// ConvertQ2dToQ1d(1, 1, mx, *ExactE, *ExactE1d);
// Extra Source terms:
void ExtraSourceWrap(const dTensor2& xpts,
const dTensor2& NOT_USED_1,
const dTensor2& NOT_USED_2,
dTensor2& e,
void* data);
L2Project_extra(1, mx, 1, 1, 20, space_order,
space_order, space_order,
&q, &aux, ExtraE, &ExtraSourceWrap, (void*)t_ptr );
ConvertQ2dToQ1d(1, 1, mx, *ExtraE, *ExtraE1d);
for( int i=1; i <= mx; i++ )
for( int k=1; k <= kmax1d; k++ )
{
// electric fields w/o source term parts added in //
double Et = sl_state.aux1d->get(i,2,2,k);
double Ett = sl_state.aux1d->get(i,2,3,k);
double Ettt = sl_state.aux1d->get(i,2,4,k);
// add in missing terms from previously set values //
sl_state.aux1d->set(i,2,2, k, Et + ExtraE1d->get(i,2,k) );
sl_state.aux1d->set(i,2,3, k, Ett + ExtraE1d->get(i,3,k) );
sl_state.aux1d->set(i,2,4, k, Ettt + ExtraE1d->get(i,4,k) );
// sl_state.aux1d->set(i,2,1, k, 0. );
// sl_state.aux1d->set(i,2,2, k, 0. );
// sl_state.aux1d->set(i,2,3, k, 0. );
// sl_state.aux1d->set(i,2,4, k, 0. );
// ADD IN EXACT ELECTRIC FIELD HERE:
// sl_state.aux1d->set(i,2,1, k, ExactE1d->get(i,1,k) );
// sl_state.aux1d->set(i,2,2, k, ExactE1d->get(i,2,k) );
// sl_state.aux1d->set(i,2,3, k, ExactE1d->get(i,3,k) );
// sl_state.aux1d->set(i,2,4, k, ExactE1d->get(i,4,k) );
}
delete ExactE;
delete ExactE1d;
delete t_ptr;
delete ExtraE;
delete ExtraE1d;
}
}
bool FeynHiggsWrapper::SetFeynHiggsPars()
{
int err;
/* FeynHiggs debug flag */
//FHSetDebug(2);
//FHSetDebug(3);
Mw_FHinput = mySUSY.Mw_tree(); /* Tree-level W-boson mass */
//Mw_FHinput = mySUSY.StandardModel::Mw(); /* SM prediction, which should not be used, since mHl cannot be set before calling FeynHiggs. */
//std::cout << "Mw = " << Mw_FHinput << " used in FeynHiggsWrapper::SetFeynHiggsPars()" << std::endl;
/* Set the FeynHiggs SM input parameters */
FHSetSMPara(&err,
1.0/mySUSY.alphaMz(),
mySUSY.getAlsMz(), mySUSY.getGF(),
mySUSY.getLeptons(StandardModel::ELECTRON).getMass(),
mySUSY.getQuarks(QCD::UP).getMass(),
mySUSY.getQuarks(QCD::DOWN).getMass(),
mySUSY.getLeptons(StandardModel::MU).getMass(),
mySUSY.getQuarks(QCD::CHARM).getMass(),
mySUSY.getQuarks(QCD::STRANGE).getMass(),
mySUSY.getLeptons(StandardModel::TAU).getMass(),
mySUSY.getQuarks(QCD::BOTTOM).getMass(),
Mw_FHinput, mySUSY.getMz(),
mySUSY.getLambda(), mySUSY.getA(), mySUSY.getRhob(), mySUSY.getEtab());
if (err != 0) {
#ifdef FHDEBUG
std::cout << "FeynHiggsWrapper::SetFeynHiggsPars(): Error has been detected in SetPara.F:"
<< err << std::endl;
#endif
return (false);
}
/* Parameters for FeynHiggs */
double Q_S = mySUSY.Q_SUSY;
gslpp::complex muHFH = mySUSY.muH;
gslpp::complex M1FH = mySUSY.m1;
gslpp::complex M2FH = mySUSY.m2;
gslpp::matrix<gslpp::complex> MsQ2 = mySUSY.msQhat2;
gslpp::matrix<gslpp::complex> MsU2 = mySUSY.msUhat2;
gslpp::matrix<gslpp::complex> MsD2 = mySUSY.msDhat2;
gslpp::matrix<gslpp::complex> MsL2 = mySUSY.msLhat2;
gslpp::matrix<gslpp::complex> MsE2 = mySUSY.msEhat2;
gslpp::matrix<gslpp::complex> KU = mySUSY.TUhat.hconjugate() * mySUSY.v2() / sqrt(2.0);
gslpp::matrix<gslpp::complex> KD = mySUSY.TDhat.hconjugate() * mySUSY.v1() / sqrt(2.0);
gslpp::matrix<gslpp::complex> KE = mySUSY.TEhat.hconjugate() * mySUSY.v1() / sqrt(2.0);
/* MFV trilinear couplings */
gslpp::vector<gslpp::complex> AU(3,0.), AD(3,0.), AE(3,0.);
for (int i=0; i<3; i++) {
int p = (int)mySUSY.UP + 2*i;
AU.assign(i, KU(i,i) / mySUSY.Mq_Q((QCD::quark)p));
p = (int)mySUSY.DOWN + 2*i;
AD.assign(i, KD(i,i) / mySUSY.Mq_Q((QCD::quark)p));
p = (int)mySUSY.ELECTRON + 2*i;
AE.assign(i, KE(i,i) / mySUSY.Ml_Q((StandardModel::lepton)p));
}
/* Check if non-minimal flavor-violating (NMFV) entries exist in the
* sfermion mass matrices. See also IniFV() in SetFV.F of FeynHiggs. */
NMFVu = true; NMFVd = true; NMFVe = true;// NMFVnu = true;
double TMPu = 0.0, TMPd = 0.0, TMPe = 0.0; //TMPnu = 0.0
for (int i=0; i<3; i++) {
for (int j=0; j<3; j++) {
if (i < j) {
TMPu += MsQ2(i, j).abs2() + MsU2(i, j).abs2();
TMPd += MsQ2(i, j).abs2() + MsD2(i, j).abs2();
//TMPnu += MsL2(i, j).abs2(); /* not used */
TMPe += MsL2(i, j).abs2() + MsE2(i, j).abs2();
}
if (i != j) {
TMPu += KU(i, j).abs2();
TMPd += KD(i, j).abs2();
TMPe += KE(i, j).abs2();
}
}
}
if (!TMPu) NMFVu = false;
if (!TMPe) NMFVd = false;
if (!TMPe) NMFVe = false;
/* NMFV trilinear couplings. In the case of NMFV, the trilinear couplings
* AU, AD and AE for FHSetPara() as well as KU, KD and KE for FHSetNMFV()
* and FHSetLFV() have to be rotated. */
gslpp::complex muHphase(1.0, - 2.0*muHFH.arg(), true);
if (NMFVu) AU *= muHphase;
if (NMFVd) AD *= muHphase;
if (NMFVe) AE *= muHphase;
KU *= muHphase;
KD *= muHphase;
KE *= muHphase;
/* NMFV parameters for FeynHiggs */
gslpp::matrix<gslpp::complex> deltaQLL(3,3,0.);
gslpp::matrix<gslpp::complex> deltaULR(3,3,0.), deltaURL(3,3,0.), deltaURR(3,3,0.);
gslpp::matrix<gslpp::complex> deltaDLR(3,3,0.), deltaDRL(3,3,0.), deltaDRR(3,3,0.);
gslpp::matrix<gslpp::complex> deltaLLL(3,3,0.);
gslpp::matrix<gslpp::complex> deltaELR(3,3,0.), deltaERL(3,3,0.), deltaERR(3,3,0.);
for (int i=0; i<3; i++)
for (int j=0; j<3; j++) {
deltaQLL.assign(i, j, MsQ2(i,j) / sqrt(MsQ2(i,i).real() * MsQ2(j,j).real()));
deltaULR.assign(i, j, KU(i,j) / sqrt(MsQ2(i,i).real() * MsU2(j,j).real()));
deltaURL.assign(i, j, KU(j,i).conjugate() / sqrt(MsU2(i,i).real() * MsQ2(j,j).real()));
deltaURR.assign(i, j, MsU2(i,j) / sqrt(MsU2(i,i).real() * MsU2(j,j).real()));
deltaDLR.assign(i, j, KD(i,j) / sqrt(MsQ2(i,i).real() * MsD2(j,j).real()));
deltaDRL.assign(i, j, KD(j,i).conjugate() / sqrt(MsD2(i,i).real() * MsQ2(j,j).real()));
deltaDRR.assign(i, j, MsD2(i,j) / sqrt(MsD2(i,i).real() * MsD2(j,j).real()));
deltaLLL.assign(i, j, MsL2(i,j) / sqrt(MsL2(i,i).real() * MsL2(j,j).real()));
deltaELR.assign(i, j, KE(i,j) / sqrt(MsL2(i,i).real() * MsE2(j,j).real()));
deltaERL.assign(i, j, KE(j,i).conjugate() / sqrt(MsE2(i,i).real() * MsL2(j,j).real()));
deltaERR.assign(i, j, MsE2(i,j) / sqrt(MsE2(i,i).real() * MsE2(j,j).real()));
}
/* Set the FeynHiggs parameters, where the GUT relation is used for M1=0. */
FHSetPara(&err,
mySUSY.mut/mySUSY.quarks[QCD::TOP].getMass(),
mySUSY.mtpole, mySUSY.tanb,
mySUSY.mHptree, // as now used, "mHptree" is a name for MA0. We shall be using mA instead of mHptree
-1, // this is now not used, the mHptree
//
sqrt(MsL2(2,2).real()), sqrt(MsE2(2,2).real()),
sqrt(MsQ2(2,2).real()), sqrt(MsU2(2,2).real()),
sqrt(MsD2(2,2).real()),
sqrt(MsL2(1,1).real()), sqrt(MsE2(1,1).real()),
sqrt(MsQ2(1,1).real()), sqrt(MsU2(1,1).real()),
sqrt(MsD2(1,1).real()),
sqrt(MsL2(0,0).real()), sqrt(MsE2(0,0).real()),
sqrt(MsQ2(0,0).real()), sqrt(MsU2(0,0).real()),
sqrt(MsD2(0,0).real()),
//
ToComplex2(muHFH.real(), muHFH.imag()),
//
ToComplex2(AE(2).real(), AE(2).imag()),
ToComplex2(AU(2).real(), AU(2).imag()),
ToComplex2(AD(2).real(), AD(2).imag()),
ToComplex2(AE(1).real(), AE(1).imag()),
ToComplex2(AU(1).real(), AU(1).imag()),
ToComplex2(AD(1).real(), AD(1).imag()),
ToComplex2(AE(0).real(), AE(0).imag()),
ToComplex2(AU(0).real(), AU(0).imag()),
ToComplex2(AD(0).real(), AD(0).imag()),
//
ToComplex2(M1FH.real(), M1FH.imag()),
ToComplex2(M2FH.real(), M2FH.imag()),
ToComplex2(mySUSY.m3, 0.),
//
Q_S, Q_S, Q_S);
if (err != 0) {
#ifdef FHDEBUG
std::cout << "FeynHiggsWrapper::SetFeynHiggsPars(): Error has been detected in SetPara.F:"
<< err << std::endl;
#endif
return (false);
}
/* Set the non-minimal flavor-violating parameters in the squark sector */
FHSetNMFV(&err,
// Q_LL
ToComplex2(deltaQLL(0,1).real(), deltaQLL(0,1).imag()),
ToComplex2(deltaQLL(1,2).real(), deltaQLL(1,2).imag()),
ToComplex2(deltaQLL(0,2).real(), deltaQLL(0,2).imag()),
// U_LR
ToComplex2(deltaULR(0,1).real(), deltaULR(0,1).imag()),
ToComplex2(deltaULR(1,2).real(), deltaULR(1,2).imag()),
ToComplex2(deltaULR(0,2).real(), deltaULR(0,2).imag()),
// U_RL
ToComplex2(deltaURL(0,1).real(), deltaURL(0,1).imag()),
ToComplex2(deltaURL(1,2).real(), deltaURL(1,2).imag()),
ToComplex2(deltaURL(0,2).real(), deltaURL(0,2).imag()),
// U_RR
ToComplex2(deltaURR(0,1).real(), deltaURR(0,1).imag()),
ToComplex2(deltaURR(1,2).real(), deltaURR(1,2).imag()),
ToComplex2(deltaURR(0,2).real(), deltaURR(0,2).imag()),
// D_LR
ToComplex2(deltaDLR(0,1).real(), deltaDLR(0,1).imag()),
ToComplex2(deltaDLR(1,2).real(), deltaDLR(1,2).imag()),
ToComplex2(deltaDLR(0,2).real(), deltaDLR(0,2).imag()),
// D_RL
ToComplex2(deltaDRL(0,1).real(), deltaDRL(0,1).imag()),
ToComplex2(deltaDRL(1,2).real(), deltaDRL(1,2).imag()),
ToComplex2(deltaDRL(0,2).real(), deltaDRL(0,2).imag()),
// D_RR
ToComplex2(deltaDRR(0,1).real(), deltaDRR(0,1).imag()),
ToComplex2(deltaDRR(1,2).real(), deltaDRR(1,2).imag()),
ToComplex2(deltaDRR(0,2).real(), deltaDRR(0,2).imag())
);
if (err != 0) {
#ifdef FHDEBUG
std::cout << "FeynHiggsWrapper::SetFeynHiggsPars(): Error was detected in SetFV.F:"
<< err << std::endl;
#endif
return (false);
}
/* Set the non-minimal flavor-violating parameters in the slepton sector,
* which are not used to compute the sneutrino mass spectrum. */
FHSetLFV(&err,
// L_LL
ToComplex2(deltaLLL(0,1).real(), deltaLLL(0,1).imag()),
ToComplex2(deltaLLL(1,2).real(), deltaLLL(1,2).imag()),
ToComplex2(deltaLLL(0,2).real(), deltaLLL(0,2).imag()),
// E_LR
ToComplex2(deltaELR(0,1).real(), deltaELR(0,1).imag()),
ToComplex2(deltaELR(1,2).real(), deltaELR(1,2).imag()),
ToComplex2(deltaELR(0,2).real(), deltaELR(0,2).imag()),
// E_RL
ToComplex2(deltaERL(0,1).real(), deltaERL(0,1).imag()),
ToComplex2(deltaERL(1,2).real(), deltaERL(1,2).imag()),
ToComplex2(deltaERL(0,2).real(), deltaERL(0,2).imag()),
// E_RR
ToComplex2(deltaERR(0,1).real(), deltaERR(0,1).imag()),
ToComplex2(deltaERR(1,2).real(), deltaERR(1,2).imag()),
ToComplex2(deltaERR(0,2).real(), deltaERR(0,2).imag())
);
if (err != 0) {
#ifdef FHDEBUG
std::cout << "FeynHiggsWrapper::SetFeynHiggsPars(): Error was detected in SetFV.F:"
<< err << std::endl;
#endif
return (false);
}
computeHiggsCouplings = true;
computeHiggsProd = true;
computeConstraints = true;
computeFlavour = true;
return (true);
}
