StandardModel<Two_scale>::StandardModel(const StandardModel<Two_scale>& s)
: yu(s.yu), yd(s.yd), ye(s.ye), g(s.g)
{
setPars(numStandardModelPars);
setMu(s.displayMu());
setLoops(s.displayLoops());
setThresholds(s.displayThresholds());
}
StandardModel<Two_scale>::StandardModel()
: yu(3, 3), yd(3, 3), ye(3, 3), g(3)
, precision(1.0e-3)
{
setPars(numStandardModelPars);
setMu(0.0);
setLoops(1);
setThresholds(0);
}
StandardModel<Two_scale>::StandardModel(const DoubleMatrix& SMu, const DoubleMatrix& SMd,
const DoubleMatrix& SMe, const DoubleVector& g_)
: yu(SMu), yd(SMd), ye(SMe), g(g_)
{
setPars(numStandardModelPars);
setMu(0.0);
setLoops(1);
setThresholds(0);
}
void Leapforg::setEquation(double l, double r, double mu,
SourceTerm st, BoundaryCond initial,
BoundaryCond lb, BoundaryCond rb)
{
setInterval(l, r);
setMu(mu);
setSourceTerm(st);
setInitialCond(initial);
setBoundaryCond(1.0, 0.0, lb, 1.0, 0.0, rb);
}
void MssmSusy::setSusy(const MssmSusy & s) {
setLoops(s.displayLoops());
setThresholds(s.displayThresholds());
setMu(s.displayMu());
setYukawaMatrix(YU, s.displayYukawaMatrix(YU));
setYukawaMatrix(YD, s.displayYukawaMatrix(YD));
setYukawaMatrix(YE, s.displayYukawaMatrix(YE));
setHvev(s.displayHvev());
setTanb(s.displayTanb());
setSusyMu(s.displaySusyMu());
setAllGauge(s.displayGauge());
}
const StandardModel<Two_scale>& StandardModel<Two_scale>::operator=(const StandardModel<Two_scale>& s)
{
if (this == &s) return *this;
yu = s.yu;
yd = s.yd;
ye = s.ye;
g = s.g;
setMu(s.displayMu());
setLoops(s.displayLoops());
setThresholds(s.displayThresholds());
return *this;
}
const QedQcd & QedQcd::operator=(const QedQcd & m) {
if (this == &m) return *this;
a = m.a;
mf = m.mf;
mbPole = m.mbPole;
input = m.input;
ckm = m.ckm;
pmns = m.pmns;
setLoops(m.displayLoops());
setThresholds(m.displayThresholds());
setMu(m.displayMu());
return *this;
}
AdaptiveSO2CPGSynPlas::AdaptiveSO2CPGSynPlas(Neuron* perturbingNeuron)
: ExtendedSO2CPG(perturbingNeuron){
setAlpha(1.01);
setPhi(0.3);
setMu(1.00);
setGamma(0.02);
setEpsilon(0.03);
setBeta(0.00);
// for a range of P from -1 to 1
setBetaDynamics (-1.0, 0.003, 0.0000);
setGammaDynamics (-1.0, 0.003, 1.0000);
setEpsilonDynamics(0.04, 0.003, 0.0001);
}
//Does the actual calling of Runge Kutta: default precision is TOLERANCE defined in
//def.h
//Returns >0 if there's a problem with the running
int RGE::callRK(double x1, double x2, DoubleVector & v,
DoubleVector (*derivs)(double, const DoubleVector &),
double eps) {
double tol;
if (eps < 0.0) tol = TOLERANCE;
else if (eps < EPSTOL) tol = EPSTOL;
else tol = eps;
// x1 == x2 with high precision
if (close(fabs(x1), fabs(x2), EPSTOL)) return 0;
// RGE in terms of natural log of renormalisation scale
double from = log(fabs(x1));
double to = log(fabs(x2));
double guess = (from - to) * 0.1; //first step size
double hmin = (from - to) * tol * 1.0e-5;
int err =
integrateOdes(v, from, to, tol, guess, hmin, derivs, odeStepper);
setMu(x2);
return err;
}
void
SymmIsotropicElasticityTensor::setShearModulus(const Real k)
{
setMu(k);
}
void set_scale(double scale) { setMu(scale); }
GM(const arma::vec & mu, const arma::mat & sigma) {
setMu(mu);
setSigma(sigma);
}
//create gaussian model with the highest loglikelyhood for the given data
GM(const arma::mat& data) {
setMu(arma::conv_to<arma::vec>::from(arma::mean(data, 1)));
setSigma(arma::cov(data.t()));
}
