void update_ion_temp(recomb_t *thisRecombRates, double dens_old, double dens, double *Xe_old, double *Xe, double *temp_old, double *temp, double z_old, double z, double gamma, double n, double xray_heating, double Hubble)
{
int temp_index = temp_recomb_index(thisRecombRates, *temp_old);
double recomb = thisRecombRates->recHII[temp_index];
*Xe = update_ion_smallXe(n*dens, *Xe_old, recomb, z, z_old, gamma, Hubble);
*temp = update_temp(dens_old, dens, *Xe_old, *Xe, *temp_old, z, z_old, xray_heating, Hubble);
// printf("Xe_old = %e\t Xe = %e\t z_old = %e\t z = %e\n", *Xe_old, *Xe, z_old, 0.5*(z_old+z));
// if((*Xe)-(*Xe_old) > 0.1)
// {
// update_ion_temp(thisRecombRates, dens_old, dens, Xe_old, Xe, temp_old, temp, z_old, 0.5*(z_old+z), gamma, n, xray_heating, Hubble);
// update_ion_temp(thisRecombRates, dens_old, dens, Xe_old, Xe, temp_old, temp, 0.5*(z_old+z), z, gamma, n, xray_heating, Hubble);
// }
if((*Xe) > 0.01)
{
*Xe = update_ion_constdens(n*dens*CUB(1.+z_old), *Xe_old, recomb, z, z_old, gamma, Hubble);
*temp = update_temp(dens_old, dens, *Xe_old, *Xe, *temp_old, z, z_old, xray_heating, Hubble);
}
if(isnan(*Xe))
{
printf("NAN alarm! Xe = %e\t Xe_old = %e\t gamma = %e\t n = %e\t dens = %e\t temp = %e\t recomb = %e\t Hubble = %e\n", *Xe, *Xe_old, gamma, n, dens, *temp_old, recomb, Hubble);
}
Xe_old = Xe;
temp_old = temp;
}
void LiquidTransport::getSpeciesViscosities(doublereal* visc) {
update_temp();
if (!m_visc_temp_ok) {
updateViscosity_temp();
}
copy(m_viscSpecies.begin(), m_viscSpecies.end(), visc);
}
Thermostat_None::Thermostat_None(Box& box, double dt):
Thermostat(box, dt) {
update_temp();
dtime(dt);
SimBox.update_VerletLists();
SimBox.calculate_forces_verlet();
}
void LiquidTransport::getSpeciesDiffusiveMassFluxes(doublereal* const fluxes) {
int n, k;
update_temp();
update_conc();
getMixDiffCoeffs(DATA_PTR(m_spwork));
const array_fp& mw = m_thermo->molecularWeights();
const doublereal* const y = m_thermo->massFractions();
const doublereal rhon = m_thermo->molarDensity();
// Unroll wrt ndim
vector_fp sum(m_nDim,0.0);
for (n = 0; n < m_nDim; n++) {
for (k = 0; k < m_nsp; k++) {
fluxes[n*m_nsp + k] = -rhon * mw[k] * m_spwork[k] * m_Grad_X[n*m_nsp + k];
sum[n] += fluxes[n*m_nsp + k];
}
}
// add correction flux to enforce sum to zero
for (n = 0; n < m_nDim; n++) {
for (k = 0; k < m_nsp; k++) {
fluxes[n*m_nsp + k] -= y[k]*sum[n];
}
}
}
/*
* The viscosity is computed using the Wilke mixture rule.
* \f[
* \mu = \sum_k \frac{\mu_k X_k}{\sum_j \Phi_{k,j} X_j}.
* \f]
* Here \f$ \mu_k \f$ is the viscosity of pure species \e k,
* and
* \f[
* \Phi_{k,j} = \frac{\left[1
* + \sqrt{\left(\frac{\mu_k}{\mu_j}\sqrt{\frac{M_j}{M_k}}\right)}\right]^2}
* {\sqrt{8}\sqrt{1 + M_k/M_j}}
* \f]
* @see updateViscosity_T();
*/
doublereal LiquidTransport::viscosity() {
update_temp();
update_conc();
if (m_visc_mix_ok) return m_viscmix;
// update viscSpecies_[] and m_phi[] if necessary
if (!m_visc_temp_ok) {
updateViscosity_temp();
}
if (!m_visc_conc_ok) {
updateViscosities_conc();
}
if (viscosityModel_ == LVISC_CONSTANT) {
return m_viscmix;
} else if (viscosityModel_ == LVISC_MIXTUREAVG) {
m_viscmix = dot_product(viscSpecies_, m_molefracs);
} else if (viscosityModel_ == LVISC_WILKES) {
multiply(m_phi, DATA_PTR(m_molefracs), DATA_PTR(m_spwork));
m_viscmix = 0.0;
for (int k = 0; k < m_nsp; k++) {
m_viscmix += m_molefracs[k] * viscSpecies_[k]/m_spwork[k];
}
}
return m_viscmix;
}
void GeneralInfo::onTimerEvent()
{
time_t t;
char buf[32];
struct tm *tm;
t = time(NULL);
tm = localtime(&t);
snprintf(buf, sizeof(buf), "%s%02d:%02d:%02d",
(tm->tm_hour < 12 ? "上午" : "下午"),
(tm->tm_hour < 12 ? tm->tm_hour : tm->tm_hour - 12),
tm->tm_min, tm->tm_sec);
text_data[TIME]->settext(buf);
#ifdef BUILD_FOR_ANDROID
update_temp();
update_sysfs(SB_SYSFS_PATH_BATTERY_VOLTAGE, BATTVOL);
update_sysfs(USB_LIMIT_CURRENT, ILIMITUSB);
update_sysfs(SB_SYSFS_PATH_BATTERY_CURRENT, BATTCUR);
update_sysfs(SB_SYSFS_PATH_BATTERY_CAPACITY, BATTCAP);
#endif
refresh_all();
}
void run_tasks()
{
if(task_flags & task_15ms_flag)
{
Page_Event_Handler();
led_state_machine();
run_oven_state_machine();
task_flags &=~task_15ms_flag;
}
if(task_flags & task_32ms_flag)
{
task_flags &=~task_32ms_flag;
update_temp();
}
if(task_flags & task_62ms_flag)
{
if(Get_LED_Timer_Status())
{
GLED_Sequence();
RLED_Sequence();
BLED_Sequence();
task_flags &=~task_62ms_flag;
}
}
if(task_flags & task_250ms_flag)
{
task_flags &=~task_250ms_flag;
}
if(task_flags & task_500ms_flag)
{
setColor16(COLOR_16_WHITE);
get_system_time_string(text_buffer);
drawString(10,160,text_buffer);
print_oven_data();
if(task_flags & graph_update)
{
update_graph();
task_flags &= ~graph_update;
}
task_flags &=~task_500ms_flag;
//RLED_OUT ^= RLED;
}
}
void LiquidTransport::getBinaryDiffCoeffs(size_t ld, doublereal* d) {
update_temp();
// if necessary, evaluate the binary diffusion coefficents
// from the polynomial fits
if (!m_diff_temp_ok) updateDiff_temp();
doublereal pres = m_thermo->pressure();
doublereal rp = 1.0/pres;
for (size_t i = 0; i < m_nsp; i++)
for (size_t j = 0; j < m_nsp; j++) {
d[ld*j + i] = rp * m_bdiff(i,j);
}
}
Nose_Hoover::Nose_Hoover(Box& box, double dt, double temp, double a_q1, double a_q2 )
: Thermostat(box, dt),
TargetTemperature(temp)
, q1(a_q1)
, q2(a_q2)
, xi1(0.0)
, xi2(0.0)
, nuxi1(0.0)
, nuxi2(0.0)
, g1(0.0)
, g2(0.0) {
DeltaTHalf = 0.5*dt;
DeltaT4 = 0.5*DeltaTHalf;
DeltaT8 = 0.5*DeltaT4;
update_temp();
dtime(dt);
SimBox.calculate_forces();
}
int clock_main()
{
sys_init();
gpio_init();
timer0_init();
lcd_init();
ds1623_init();
lcd_fill_rect(0, 0, 240, 320, 0x0000);
int i = 0;
for(;;)
{
ms_delay(1000);
update_clock();
update_temp();
}
return 0;
}
/*
* The thermal conductivity is computed from the following mixture rule:
* \[
* \lambda = 0.5 \left( \sum_k X_k \lambda_k
* + \frac{1}{\sum_k X_k/\lambda_k}\right)
* \]
*/
doublereal LiquidTransport::thermalConductivity() {
update_temp();
update_conc();
if (!m_cond_temp_ok) {
updateCond_temp();
}
if (!m_cond_mix_ok) {
doublereal sum1 = 0.0, sum2 = 0.0;
for (size_t k = 0; k < m_nsp; k++) {
sum1 += m_molefracs[k] * m_condSpecies[k];
sum2 += m_molefracs[k] / m_condSpecies[k];
}
m_lambda = 0.5*(sum1 + 1.0/sum2);
m_cond_mix_ok = true;
}
return m_lambda;
}
/*
* The viscosity is computed using the Wilke mixture rule.
* \f[
* \mu = \sum_k \frac{\mu_k X_k}{\sum_j \Phi_{k,j} X_j}.
* \f]
* Here \f$ \mu_k \f$ is the viscosity of pure species \e k,
* and
* \f[
* \Phi_{k,j} = \frac{\left[1
* + \sqrt{\left(\frac{\mu_k}{\mu_j}\sqrt{\frac{M_j}{M_k}}\right)}\right]^2}
* {\sqrt{8}\sqrt{1 + M_k/M_j}}
* \f]
* @see updateViscosity_T();
*/
doublereal LiquidTransport::viscosity() {
update_temp();
update_conc();
if (m_visc_mix_ok) return m_viscmix;
// update m_viscSpecies[] if necessary
if (!m_visc_temp_ok) {
updateViscosity_temp();
}
if (!m_visc_conc_ok) {
updateViscosities_conc();
}
/* We still need to implement interaction parameters */
/* This constant viscosity model has no input */
if (viscosityModel_ == LVISC_CONSTANT) {
err("constant viscosity not implemented for LiquidTransport.");
//return m_viscmix;
} else if (viscosityModel_ == LVISC_AVG_ENERGIES) {
m_viscmix = exp( dot_product(m_logViscSpecies, m_molefracs) );
} else if (viscosityModel_ == LVISC_INTERACTION) {
// log_visc_mix = sum_i (X_i log_visc_i) + sum_i sum_j X_i X_j G_ij
double interaction = dot_product(m_logViscSpecies, m_molefracs);
for (size_t i = 0; i < m_nsp; i++)
for (size_t j = 0; j < i; j++ )
interaction += m_molefracs[i] * m_molefracs[j]
* ( m_visc_Sij(i,j) + m_visc_Eij(i,j) / m_temp );
m_viscmix = exp( interaction );
}
return m_viscmix;
}
/**
* Mixture-averaged diffusion coefficients [m^2/s].
*
* For the single species case or the pure fluid case
* the routine returns the self-diffusion coefficient.
* This is need to avoid a Nan result in the formula
* below.
*/
void LiquidTransport::getMixDiffCoeffs(doublereal* const d) {
update_temp();
update_conc();
// update the binary diffusion coefficients if necessary
if (!m_diff_temp_ok) {
updateDiff_temp();
}
int k, j;
doublereal mmw = m_thermo->meanMolecularWeight();
doublereal sumxw_tran = 0.0;
doublereal sum2;
if (m_nsp == 1) {
d[0] = m_bdiff(0,0);
} else {
for (k = 0; k < m_nsp; k++) {
sumxw_tran += m_molefracs_tran[k] * m_mw[k];
}
for (k = 0; k < m_nsp; k++) {
sum2 = 0.0;
for (j = 0; j < m_nsp; j++) {
if (j != k) {
sum2 += m_molefracs_tran[j] / m_bdiff(j,k);
}
}
// Because we use m_molefracs_tran, sum2 must be positive definate
// if (sum2 <= 0.0) {
// d[k] = m_bdiff(k,k);
// } else {
d[k] = (sumxw_tran - m_molefracs_tran[k] * m_mw[k])/(mmw * sum2);
// }
}
}
}
static void inbox_received_callback(DictionaryIterator *iterator, void *context) {
update_temp(iterator, context);
}
