double effectiveE(double Ee, double Emax, double t, double r, Particle& p, State& st)
{
double Eeffmin, Eeffmax, Eeff_int, sum_Eeff, dEeff, dtau_eff;
Eeffmin = Ee;
Eeffmax = Emax;
double Eeff = Eeffmin;
Eeff_int = pow((Eeffmax / Eeffmin), 0.01); //0.00001
sum_Eeff = 0.0;
while ((sum_Eeff <= t) && (Eeff <= Eeffmax)) {// for (int k=0; k<=100000; ++k) {
dEeff = Eeff*(Eeff_int - 1.0);
dtau_eff = dEeff / losses(Eeff, r, p, st);
sum_Eeff = sum_Eeff + dtau_eff;
// if (sum_Eeff > times[j]) goto
Eeff = Eeff*Eeff_int;
}
return Eeff;
}
Team::Team(QObject *parent, const char *name)
: QObject(parent,name) {
wins(0);
losses(0);
ties(0);
goals(0);
generations(0);
Bots.clear();
}
Real
BubbleBase::computeQpJacobian()
{
Real losses(0);
Real gains(0);
calcLosses(losses, true);
calcGains(gains, true);
return -( gains - losses ) * _phi[_j][_qp] * _test[_i][_qp];
}
Real
BubbleBase::computeQpResidual()
{
Real losses(0);
Real gains(0);
calcLosses(losses, false);
calcGains(gains, false);
return -( gains - losses ) * _test[_i][_qp];
}
void Team::randomTeam(unsigned int size) {
unsigned int numrules;
unsigned int mass;
wins(0);
losses(0);
ties(0);
goals(0);
name("Team Stochastic");
for (unsigned int i=0; i<size; i++) {
numrules = Random::randint(100,200); // pick a random number of rules for each bot
mass = Random::randint(1,10); // pick a random number for the bot mass
Bot *NewBot = new Bot(this);
NewBot->randomBot(numrules, mass);
insertBot(NewBot);
}
}
void distribution(Particle& p, State& st)
{
static const double Gamma = GlobalConfig.get<double>("Gamma");
show_message(msgStart, Module_electronDistribution);
const ParamSpace& ps{ p.ps };
const double rmin = ps[DIM_R].first();
const double rmax = ps[DIM_R].last();
const int nR = ps[DIM_R].size()-1;
ParamSpaceValues N2(p.ps);
N2.fill([&](const SpaceIterator& i){
return 0.0;
});
ParamSpaceValues N12(p.ps);
N12.fill([&](const SpaceIterator& i){
return 0.0;
});
static const std::string injector = GlobalConfig.get<std::string>("injector");
bool multiple = (injector == "multiple");
bool single = (injector == "single");
int superior;
superior = p.ps[1].size(); //este es el caso de multiple
for (int t_ix = 0; t_ix < p.ps[2].size(); t_ix++) {
//for (int z_ix = 0; z_ix < p.ps[1].size(); z_ix++) { //emisores para todo z
//for (int z_ix = 0; z_ix <= t_ix; z_ix++) { //unico emisor en z=0
if (single) { superior = t_ix + 1; }
//el +1 es para que el for incluya el t_ix
for (int z_ix = 0; z_ix < superior; z_ix++) {
N2.ps.iterate([&](const SpaceIterator& i){
N2.set(i, p.distribution.get(i)); //copia del N
}); //ver si quizas lo puedo copiar en t-1 que es donde lo necesito
p.ps.iterate([&](const SpaceIterator& i){
const double E = i.val(DIM_E);
const double r = i.val(DIM_R);
const double t = i.val(DIM_T);
const double magf = st.magf.get(i);
//
// equivale a:
// i.its[0].val();
// i.its[0].peek(DIM_E);
//
// equivalia a:
// ex i.par.T;
double Emax = eEmax(r, magf);
double tp = t / Gamma; //time in the FF
if (E < Emax){
double Eeff = effectiveE(E, Emax, tp, r, p, st, i);
double dist1(0.0), dist2(0.0);
dist1 = timeDistribution(E, r, tp, p, st, Eeff, i);
if (t_ix != 0)
{ //estos son los puntos donde Q=0, y las particulas vienen de ti-1
//if (i.its[2].canPeek(-1))
double dist = N2.interpolate({ { DIM_E, Eeff }, { DIM_R, r }, { DIM_T, i.its[2].peek(-1) } });
double ratioLosses = losses(Eeff, r, p, st, i) / losses(E, r, p, st, i);
dist2 = dist*ratioLosses;
}
N12.set(i, dist1 + dist2); //lo cargo en N12 mientras interpolo de N2
//N12.set(i, dist1); //lo cargo en N12 mientras interpolo de N2
}
else
{
N12.set(i, 0.0); //si E>Emax entonces anulo la N
}
}, { -1, z_ix, t_ix });
p.ps.iterate([&](const SpaceIterator& i){
double ni = N12.get(i); //el ni es que que obtengo con N12
double dist3;
double ri = i.its[1].peek(0);
double rip1;
if (i.its[1].canPeek(-1)) //if (z_ix != 0)
{
SpaceCoord coord = i.moved({ 0, -1, 0 }); //N(ri-1)
double ni_1 = p.distribution.get(coord); //este lo calculo con el p.dist porque ya esta en r-1
double ri_1 = i.its[1].peek(-1);
if (i.its[1].canPeek(1)) { rip1 = i.its[1].peek(+1); }
else{
double r_int = pow((rmax / rmin), (1.0 / nR));
rip1 = ri*r_int;
}
dist3 = ni*(1.0 - ri / rip1) + ni_1*(ri_1 / ri);
}
else //z_ix=0
{
rip1 = i.its[1].peek(+1);
dist3 = ni*(1.0 - ri / rip1);
}
p.distribution.set(i,dist3); // lleno p.distribution e interpolo en N12
//p.distribution.set(i, ni); // prueba
} , { -1, z_ix, t_ix });
}//for sobre r
}//for sobre t
show_message(msgEnd, Module_electronDistribution);
}
double timeDistribution(double Ee, double r, double t, Particle& p, State& st, double Eeff)
{
//aca declaro las variables del bucle
//double Eeff este no lo declaro porque lo paso como argumento
//double Eeffmin, Eeffmax, Eeff_int, sum_Eeff, dEeff, dtau_eff;
double dtau, tau;
double EpMin, EpMax, Ep, Ep_int, sum_Ep, dEp;
double EppMin, EppMax, Epp, Epp_int, sum_Epp, dEpp;
double perdidas, inj, dist, t_cool, t_carac;
////////////////CON ESTE IF CONTROLO SI LAS PERDIDAS SON RELEVANTES FRENTE A Tadv+Tdec//////////////////////
perdidas = losses(Ee, r, p, st);
t_cool = Ee/perdidas;
//t_esc = escapeTime(Ee, p);
//comento el siguiente if porque Tesc-> inf
//por lo que las perdidas siempre dominan
//if (t_cool <= t){// (t_cool <= t_esc)){ //| (t_cool <= Time[j]) ) { //perdidas importantes
///////////////BUSCO EL Eeff/////////////////////////////////////////////
//double Eeff = effectiveE(Ee, Emax, t, p, st);
///////////////////YA ENCONTRE EL Eeff/////////////////////////////////////
//lo calculo para todo t porque lo necesito independientemente del siguiente if
if (t_cool <= t) {
///////////////////AHORA CALCULO LA INTEGRAL "DOBLE" QUE DA N(E,t)/////////////////////////////////////
EpMin = Ee; //Ep = Eprima
EpMax = Eeff;
Ep = EpMin;
Ep_int = pow((EpMax/EpMin),0.01); //0.001
sum_Ep = 0.0;
for (size_t l=0; l <= 10; ++l) { //100
dEp = Ep*(Ep_int-1.0);
////aca calculo la integral del exponente con variable Epp = E'' //////////////
EppMin = Ee; //Ep = Eprima
EppMax = Ep;
Epp = EppMin;
Epp_int = pow((EppMax/EppMin),0.01);
sum_Epp = 0.0;
//sum_dexp = 0.0;
if (EppMax > EppMin) {
for (size_t n=0; n <= 10; ++n) { //100
dEpp = Epp*(Epp_int-1.0);
dtau = dEpp/losses(Epp, r, p, st);
//dexp = dtau/escapeTime(Epp,p);
sum_Epp = sum_Epp + dtau;
//sum_dexp = sum_dexp + dexp;
Epp = Epp*Epp_int;
}
}
tau = sum_Epp;
/////////////////// ya calcule el tau ////////////////////////////
double teval = 0.0;
double tmin = st.electron.ps[2][0]; //el siguiente if es para no interpolar fuera del rango
if (t - tau < tmin) {
teval = tmin;
}
else {
teval = t - tau;
}
double Emax = eEmax(r, magneticField);
if (Ep > Emax) {
inj = 0.0;
}
else {
inj = p.injection.interpolate({ { DIM_E, Ep }, { DIM_R, r }, { DIM_T, t - tau } }); //paso los valores E,r,t en donde quiero evaluar Q
//interpolDoble(Ep, Time[j]-tau, Ee, Time, injection); //chequear que ande!
}
dist = inj; //*exp(-sum_dexp);lo comento por lo del Tesc //tau/escapeTime(Ep,particle));
sum_Ep = dist*dEp+sum_Ep;
Ep = Ep*Ep_int;
}
//particle.distribution[j*(ne+1)+i] = sum_Ep/perdidas;
double total = sum_Ep / perdidas;
dist = total;
} //aca termina la parte del if en donde tcool < T //las perdidas son importantes
else { //t_cool > t_esc or t_cool > t
t_carac = min(t_cool, t); // min(t_cool, t_esc); //min(t_esc, Time[j]));
inj = p.injection.interpolate({ { DIM_E, Ee }, { DIM_R, r }, { DIM_T, t } });// p.injection.get(i);// injection[j*(ne + 1) + i]; VER
dist = inj*t_carac; // t_esc; //t_carac; //exp(-tau*escapeTime(Ep,particle));
//particle.distribution[j*(ne+1)+i] = dist;
// return dist;
}
return dist;
}
