/**
* @brief
*/
static void Ms_Frame(void) {
const time_t now = time(NULL);
GList *s = ms_servers;
while (s) {
ms_server_t *server = (ms_server_t *) s->data;
if (now - server->last_heartbeat > 30) {
if (server->queued_pings > 6) {
Com_Print("Server %s timed out\n", stos(server));
Ms_DropServer(server);
} else {
if (now - server->last_ping >= 10) {
server->queued_pings++;
server->last_ping = now;
Com_Verbose("Pinging %s\n", stos(server));
const char *ping = "\xFF\xFF\xFF\xFF" "ping";
sendto(ms_sock, ping, strlen(ping), 0, (struct sockaddr *) &server->addr,
sizeof(server->addr));
}
}
}
s = s->next;
}
}
/* Convert scattering parameters with the reference impedance 'zref'
to scattering parameters with the reference impedance 'z0'. */
matvec stos (matvec s, vector zref, vector z0) {
assert (s.getCols () == s.getRows () &&
s.getCols () == zref.getSize () && s.getCols () == z0.getSize ());
matvec res (s.getSize (), s.getCols (), s.getRows ());
for (int i = 0; i < s.getSize (); i++)
res.set (stos (s.get (i), zref, z0), i);
return res;
}
/**
* @brief Removes the specified server.
*/
static void Ms_RemoveServer(struct sockaddr_in *from) {
ms_server_t *server = Ms_GetServer(from);
if (!server) {
Com_Warn("Shutdown from unregistered server %s\n", atos(from));
return;
}
Com_Print("Shutdown from %s\n", stos(server));
Ms_DropServer(server);
}
/**
* @brief Acknowledge the server from the specified address.
*/
static void Ms_Ack(struct sockaddr_in *from) {
ms_server_t *server = Ms_GetServer(from);
if (server) {
Com_Verbose("Ack from %s (%d)\n", stos(server), server->queued_pings);
server->validated = true;
server->queued_pings = 0;
} else {
Com_Warn("Ack from unregistered server %s\n", atos(from));
}
}
/**
* @brief Accept a "heartbeat" from the specified server address.
*/
static void Ms_Heartbeat(struct sockaddr_in *from) {
ms_server_t *server = Ms_GetServer(from);
if (server) {
server->last_heartbeat = time(NULL);
Com_Verbose("Heartbeat from %s\n", stos(server));
const void *ack = "\xFF\xFF\xFF\xFF" "ack";
sendto(ms_sock, ack, 7, 0, (struct sockaddr *) &server->addr, sizeof(server->addr));
} else {
Ms_AddServer(from);
}
}
void
AddCoupledSolidKinSpeciesAuxKernelsAction::act()
{
std::vector<std::string> reactions = getParam<std::vector<std::string> >("kin_reactions");
std::vector<Real> logk = getParam<std::vector<Real> >("log10_keq");
std::vector<Real> r_area = getParam<std::vector<Real> >("specific_reactive_surface_area");
std::vector<Real> ref_kconst = getParam<std::vector<Real> >("kinetic_rate_constant");
std::vector<Real> e_act = getParam<std::vector<Real> >("activation_energy");
Real gas_const = getParam<Real>("gas_constant");
std::vector<Real> ref_temp = getParam<std::vector<Real> >("reference_temperature");
std::vector<Real> sys_temp = getParam<std::vector<Real> >("system_temperature");
// NEED TO ADD AN ERROR MESSAGE IF THE SIZES OF ABOVE ARRAYS ARE NOT THE SAME //
for (unsigned int j=0; j < reactions.size(); j++)
{
std::vector<std::string> tokens;
std::vector<std::string> solid_kin_species(reactions.size());
// Parsing each reaction
MooseUtils::tokenize(reactions[j], tokens, 1, "+=");
std::vector<Real> stos(tokens.size()-1);
std::vector<VariableName> rxn_vars(tokens.size()-1);
for (unsigned int k=0; k < tokens.size(); k++)
{
Moose::out << tokens[k] << "\t";
std::vector<std::string> stos_vars;
MooseUtils::tokenize(tokens[k], stos_vars, 1, "()");
if (stos_vars.size() == 2)
{
Real coef;
std::istringstream iss(stos_vars[0]);
iss >> coef;
stos[k] = coef;
rxn_vars[k] = stos_vars[1];
}
else
{
solid_kin_species[j] = stos_vars[0];
}
}
void
AddCoupledSolidKinSpeciesAction::act()
{
mooseDoOnce(printReactions());
std::vector<bool> primary_participation(_primary_species.size(), false);
std::vector<std::string> solid_kin_species(_reactions.size());
std::vector<Real> weight;
// Loop through reactions
for (unsigned int j = 0; j < _reactions.size(); ++j)
{
std::vector<std::string> tokens;
// Parsing each reaction
MooseUtils::tokenize(_reactions[j], tokens, 1, "+=");
if (tokens.size() == 0)
mooseError("Empty reaction specified.");
std::vector<Real> stos(tokens.size() - 1);
std::vector<VariableName> rxn_species(tokens.size() - 1);
for (unsigned int k = 0; k < tokens.size(); ++k)
{
std::vector<std::string> stos_primary_species;
MooseUtils::tokenize(tokens[k], stos_primary_species, 1, "()");
if (stos_primary_species.size() == 2)
{
Real coef;
std::istringstream iss(stos_primary_species[0]);
iss >> coef;
stos[k] = coef;
rxn_species[k] = stos_primary_species[1];
// Check the participation of primary species
for (unsigned int i = 0; i < _primary_species.size(); ++i)
if (rxn_species[k] == _primary_species[i])
primary_participation[i] = true;
}
else
solid_kin_species[j] = stos_primary_species[0];
}
/**
* @brief Adds the specified server to the master.
*/
static void Ms_AddServer(struct sockaddr_in *from) {
if (Ms_GetServer(from)) {
Com_Warn("Duplicate ping from %s\n", atos(from));
return;
}
if (Ms_BlacklistServer(from)) {
Com_Warn("Server %s has been blacklisted\n", atos(from));
return;
}
ms_server_t *server = Mem_Malloc(sizeof(ms_server_t));
server->addr = *from;
server->last_heartbeat = time(NULL);
ms_servers = g_list_prepend(ms_servers, server);
Com_Print("Server %s registered\n", stos(server));
// send an acknowledgment
sendto(ms_sock, "\xFF\xFF\xFF\xFF" "ack", 7, 0, (struct sockaddr *) from, sizeof(*from));
}
void
AddCoupledSolidKinSpeciesKernelsAction::act()
{
std::vector<NonlinearVariableName> vars = getParam<std::vector<NonlinearVariableName> >("primary_species");
std::vector<std::string> reactions = getParam<std::vector<std::string> >("kin_reactions");
Moose::out<< "Solid kinetic reaction list:" << "\n";
for (unsigned int i=0; i < reactions.size(); i++)
{
Moose::out<< reactions[i] << "\n";
}
for (unsigned int i=0; i < vars.size(); i++)
{
Moose::out << "primary species - " << vars[i] << "\n";
std::vector<bool> primary_participation(reactions.size(), false);
std::vector<std::string> solid_kin_species(reactions.size());
std::vector<Real> weight;
for (unsigned int j=0; j < reactions.size(); j++)
{
std::vector<std::string> tokens;
// Parsing each reaction
MooseUtils::tokenize(reactions[j], tokens, 1, "+=");
std::vector<Real> stos(tokens.size()-1);
std::vector<std::string> rxn_vars(tokens.size()-1);
for (unsigned int k=0; k < tokens.size(); k++)
{
Moose::out << tokens[k] << "\t";
std::vector<std::string> stos_vars;
MooseUtils::tokenize(tokens[k], stos_vars, 1, "()");
if (stos_vars.size() == 2)
{
Real coef;
std::istringstream iss(stos_vars[0]);
iss >> coef;
stos[k] = coef;
rxn_vars[k] = stos_vars[1];
Moose::out << "stochiometric: " << stos[k] << "\t";
Moose::out << "reactant: " << rxn_vars[k] << "\n";
// Check the participation of primary species
if (rxn_vars[k] == vars[i]) primary_participation[j] = true;
}
else
{
solid_kin_species[j] = stos_vars[0];
}
}
// Done parsing, recorded stochiometric and variables into separate arrays
Moose::out << "whether primary present (0 is not): " << primary_participation[j] << "\n";
if (primary_participation[j])
{
// Assigning the stochiometrics based on parsing
for (unsigned int m=0; m < rxn_vars.size(); m++)
{
if (rxn_vars[m] == vars[i])
{
weight.push_back(stos[m]);
Moose::out << "weight for " << rxn_vars[m] <<" : " << weight[weight.size()-1] << "\n";
}
}
Moose::out << "solid kinetic species: " << solid_kin_species[j] << "\n";
std::vector<VariableName> coupled_var(1);
coupled_var[0] = solid_kin_species[j];
// Building kernels for solid kinetic species
InputParameters params_kin = _factory.getValidParams("CoupledBEKinetic");
params_kin.set<NonlinearVariableName>("variable") = vars[i];
params_kin.set<std::vector<Real> >("weight") = weight;
params_kin.set<std::vector<VariableName> >("v") = coupled_var;
_problem->addKernel("CoupledBEKinetic", vars[i]+"_"+solid_kin_species[j]+"_kin", params_kin);
Moose::out << vars[i]+"_"+solid_kin_species[j]+"_kin" << "\n";
params_kin.print();
}
}
void stosw_yv_eax ( struct mon_t *mon, struct instruction_t *instr ) { stos ( mon, instr, 4 ); }
void stosb_yb_al ( struct mon_t *mon, struct instruction_t *instr ) { stos ( mon, instr, 1 ); }
matvec stos (matvec s, nr_complex_t zref, vector z0) {
return stos (s, vector (z0.getSize (), zref), z0);
}
matvec stos (matvec s, vector zref, nr_complex_t z0) {
return stos (s, zref, vector (zref.getSize (), z0));
}
matvec stos (matvec s, nr_double_t zref, nr_double_t z0) {
return stos (s, rect (zref, 0), rect (z0, 0));
}
matvec stos (matvec s, nr_complex_t zref, nr_complex_t z0) {
int d = s.getRows ();
return stos (s, vector (d, zref), vector (d, z0));
}
