bool DepressionFSDaily::CheckInputData() {
CHECK_POSITIVE(MID_DEP_LINSLEY, m_date);
CHECK_POSITIVE(MID_DEP_LINSLEY, m_nCells);
CHECK_NODATA(MID_DEP_LINSLEY, m_depCo);
CHECK_POINTER(MID_DEP_LINSLEY, m_depCap);
CHECK_POINTER(MID_DEP_LINSLEY, m_pet);
CHECK_POINTER(MID_DEP_LINSLEY, m_ei);
CHECK_POINTER(MID_DEP_LINSLEY, m_pe);
return true;
}
bool IUH_OL::CheckInputData() {
CHECK_POSITIVE(MID_IUH_OL, m_date);
CHECK_POSITIVE(MID_IUH_OL, m_nSubbsns);
CHECK_NONNEGATIVE(MID_IUH_OL, m_inputSubbsnID);
CHECK_POSITIVE(MID_IUH_OL, m_nCells);
CHECK_POSITIVE(MID_IUH_OL, m_CellWth);
CHECK_NONNEGATIVE(MID_IUH_OL, m_TimeStep);
CHECK_POINTER(MID_IUH_OL, m_subbsnID);
CHECK_POINTER(MID_IUH_OL, m_iuhCell);
CHECK_POINTER(MID_IUH_OL, m_surfRf);
return true;
}
void DepressionFSDaily::InitialOutputs() {
CHECK_POSITIVE(MID_DEP_LINSLEY, m_nCells);
if (nullptr == m_sd) {
Initialize1DArray(m_nCells, m_sd, 0.f);
Initialize1DArray(m_nCells, m_ed, 0.f);
Initialize1DArray(m_nCells, m_sr, 0.f);
#pragma omp parallel for
for (int i = 0; i < m_nCells; i++) {
m_sd[i] = m_depCo * m_depCap[i];
}
}
}
void SNO_SP::InitialOutputs() {
CHECK_POSITIVE(MID_SNO_SP, m_nCells);
if (nullptr == m_snowMelt) Initialize1DArray(m_nCells, m_snowMelt, 0.f);
if (nullptr == m_SA) Initialize1DArray(m_nCells, m_SA, 0.f);
if (nullptr == m_packT) Initialize1DArray(m_nCells, m_packT, 0.f);
if (nullptr == m_snowAccum) {
/// the initialization should be removed when snow redistribution module is accomplished. LJ
Initialize1DArray(m_nCells, m_snowAccum, 0.f);
}
if (nullptr == m_SE) {
/// Snow sublimation will be considered in AET_PTH
Initialize1DArray(m_nCells, m_SE, 0.f);
}
}
bool SNO_SP::CheckInputData() {
CHECK_POSITIVE(MID_SNO_SP, m_nCells);
CHECK_NODATA(MID_SNO_SP, m_t0);
CHECK_NODATA(MID_SNO_SP, m_kblow);
CHECK_NODATA(MID_SNO_SP, m_snowTemp);
CHECK_NODATA(MID_SNO_SP, m_lagSnow);
CHECK_NODATA(MID_SNO_SP, m_csnow6);
CHECK_NODATA(MID_SNO_SP, m_csnow12);
CHECK_NODATA(MID_SNO_SP, m_snowCoverMax);
CHECK_NODATA(MID_SNO_SP, m_snowCover50);
CHECK_POINTER(MID_SNO_SP, m_meanTemp);
CHECK_POINTER(MID_SNO_SP, m_maxTemp);
CHECK_POINTER(MID_SNO_SP, m_netPcp);
return true;
}
int set_find(const set *ptr, const void *needle, size_t len) {
CHECK_NOT_NULL(ptr);
CHECK_NOT_NULL(needle);
CHECK_POSITIVE(len);
size_t hash = ptr->hasher(needle, len);
for (unsigned int i=0; i < ptr->size; i++) {
size_t index = find_index(hash, i, ptr->size);
if (!ptr->map[index]) return ERR_NOT_FOUND;
// get offset, add to heap
const void *candidate = ptr->heap + ptr->map[index];
if (!memcmp(needle, candidate, len)) return SUCCESS;
}
return ERR_NOT_FOUND;
}
void IUH_OL::InitialOutputs() {
CHECK_POSITIVE(MID_IUH_OL, m_nSubbsns);
if (m_cellArea <= 0.f) m_cellArea = m_CellWth * m_CellWth;
if (nullptr == m_Q_SBOF) {
Initialize1DArray(m_nSubbsns + 1, m_Q_SBOF, 0.f);
for (int i = 0; i < m_nCells; i++) {
m_cellFlowCols = Max(CVT_INT(m_iuhCell[i][1]) + 1, m_cellFlowCols);
}
//get m_cellFlowCols, i.e. the maximum of second column of OL_IUH plus 1.
Initialize2DArray(m_nCells, m_cellFlowCols, m_cellFlow, 0.f);
}
if (nullptr == m_OL_Flow) {
Initialize1DArray(m_nCells, m_OL_Flow, 0.f);
}
}
int set_add(set *ptr, const void *element, size_t len) {
CHECK_NOT_NULL(ptr);
CHECK_NOT_NULL(element);
CHECK_POSITIVE(len);
if (!has_space(ptr, len)) return ERR_MEM;
size_t hash = ptr->hasher(element, len);
for (unsigned int i=0; i < ptr->size; i++) {
size_t index = find_index(hash, i, ptr->size);
if (!ptr->map[index]) { // insert
ptr->map[index] = ptr->tail - ptr->heap;
memcpy(ptr->tail, element, len);
ptr->tail += len;
return SUCCESS;
}
}
return ERR_SIZE;
}
//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
Signal::Signal(int f,int l) : data(0),first(f),last(l) {
//TRACER_CALL(t,"Signal::Signal");
int len=last-first+1;
CHECK_POSITIVE(len);
data=OPERATOR_NEW_BRACKET(double,len);
}
VALUE rb_create_instance(VALUE rb_obj, ...)
{
VAR_DECLARATIONS
/* initialize ap for use with the va_arg and va_end macros */
va_start(ap, rb_obj);
switch (type(rb_obj)) {
CASE(bernoulli)
VALUE rb_p;
double p;
SET_KLASS(bernoulli);
rb_p = GET_NEXT_ARG(ap);
p = NUM2DBL(rb_p);
CHECK_NUMBER(p);
/* 0 < p < 1 */
CHECK_PROBABILITY_EXCL(p);
/* p parameter correct */
RANDVAR_INIT(bernoulli);
SET_PARAM(bernoulli, p);
CASE_END
CASE(beta)
VALUE rb_alpha, rb_beta;
double alpha, beta;
SET_KLASS(beta);
rb_alpha = GET_NEXT_ARG(ap);
rb_beta = GET_NEXT_ARG(ap);
alpha = NUM2DBL(rb_alpha);
beta = NUM2DBL(rb_beta);
CHECK_NUMBER(alpha);
CHECK_NUMBER(beta);
/* alpha > 0 */
CHECK_POSITIVE(alpha);
/* beta > 0 */
CHECK_POSITIVE(beta);
/* alpha and beta parameters correct */
RANDVAR_INIT(beta);
SET_PARAM(beta, alpha);
SET_PARAM(beta, beta);
CASE_END
CASE(binomial)
VALUE rb_n, rb_p;
long n;
double p;
SET_KLASS(binomial);
rb_n = GET_NEXT_ARG(ap);
rb_p = GET_NEXT_ARG(ap);
CHECK_RB_INTEGER(rb_n, "n");
n = NUM2LONG(rb_n);
p = NUM2DBL(rb_p);
CHECK_NUMBER(p);
/* n >= 0 */
CHECK_NON_NEGATIVE(n);
/* 0 <= p <= 1 */
CHECK_PROBABILITY(p);
/* n and p parameters correct */
RANDVAR_INIT(binomial);
SET_PARAM(binomial, n);
SET_PARAM(binomial, p);
CASE_END
CASE(chi_squared)
VALUE rb_k;
long k;
SET_KLASS(chi_squared);
rb_k = GET_NEXT_ARG(ap);
CHECK_RB_INTEGER(rb_k, "k");
k = NUM2LONG(rb_k);
/* k > 0 */
CHECK_POSITIVE(k);
/* k parameter correct */
RANDVAR_INIT(chi_squared);
SET_PARAM(chi_squared, k);
CASE_END
CASE(continuous_uniform)
VALUE rb_a, rb_b;
double a,b;
SET_KLASS(continuous_uniform);
rb_a = GET_NEXT_ARG(ap);
rb_b = GET_NEXT_ARG(ap);
a = NUM2DBL(rb_a);
b = NUM2DBL(rb_b);
CHECK_NUMBER(a);
CHECK_NUMBER(b);
/* a < b */
CHECK_LESS_THAN(a,b);
/* a and b parameters correct */
RANDVAR_INIT(continuous_uniform);
SET_PARAM(continuous_uniform, a);
SET_PARAM(continuous_uniform, b);
CASE_END
CASE(discrete_uniform)
VALUE rb_a, rb_b;
long a,b;
SET_KLASS(discrete_uniform);
rb_a = GET_NEXT_ARG(ap);
rb_b = GET_NEXT_ARG(ap);
CHECK_RB_INTEGER(rb_a, "a");
CHECK_RB_INTEGER(rb_b, "b");
a = NUM2LONG(rb_a);
b = NUM2LONG(rb_b);
/* a < b */
CHECK_LESS_THAN(a,b);
/* a and b parameters correct */
RANDVAR_INIT(discrete_uniform);
SET_PARAM(discrete_uniform, a);
SET_PARAM(discrete_uniform, b);
CASE_END
CASE(exponential)
VALUE rb_mean;
double mean;
SET_KLASS(exponential);
rb_mean = GET_NEXT_ARG(ap);
mean = NUM2DBL(rb_mean);
CHECK_NUMBER(mean);
/* mean > 0 */
CHECK_POSITIVE(mean);
/* mean parameter correct */
RANDVAR_INIT(exponential);
SET_PARAM(exponential, mean);
CASE_END
CASE(f)
VALUE rb_d1, rb_d2;
double d1, d2;
SET_KLASS(f);
rb_d1 = GET_NEXT_ARG(ap);
rb_d2 = GET_NEXT_ARG(ap);
d1 = NUM2DBL(rb_d1);
d2 = NUM2DBL(rb_d2);
CHECK_NUMBER(d1);
CHECK_NUMBER(d2);
/* d1 > 0 */
/* d2 > 0 */
CHECK_POSITIVE(d1);
CHECK_POSITIVE(d2);
/* d1, d2 parameters correct */
RANDVAR_INIT(f);
SET_PARAM(f, d1);
SET_PARAM(f, d2);
CASE_END
CASE(negative_binomial)
VALUE rb_r, rb_p;
long r;
double p;
SET_KLASS(negative_binomial);
rb_r = GET_NEXT_ARG(ap);
rb_p = GET_NEXT_ARG(ap);
CHECK_RB_INTEGER(rb_r, "r");
r = NUM2LONG(rb_r);
p = NUM2DBL(rb_p);
CHECK_NUMBER(p);
/* r > 0 */
CHECK_POSITIVE(r);
/* 0 < p < 0 */
CHECK_PROBABILITY_EXCL(p);
/* r and p parameters correct */
RANDVAR_INIT(negative_binomial);
SET_PARAM(negative_binomial, r);
SET_PARAM(negative_binomial, p);
CASE_END
CASE(normal)
VALUE rb_mu, rb_sigma;
double mu, sigma;
SET_KLASS(normal);
rb_mu = GET_NEXT_ARG(ap);
rb_sigma = GET_NEXT_ARG(ap);
mu = NUM2DBL(rb_mu);
sigma = NUM2DBL(rb_sigma);
CHECK_NUMBER(mu);
CHECK_NUMBER(sigma);
/* sigma > 0 */
CHECK_POSITIVE(sigma);
/* sigma parameter correct */
RANDVAR_INIT(normal);
SET_PARAM(normal, mu);
SET_PARAM(normal, sigma);
CASE_END
CASE(pareto)
VALUE rb_a, rb_m;
double a, m;
SET_KLASS(pareto);
rb_a = GET_NEXT_ARG(ap);
rb_m = GET_NEXT_ARG(ap);
a = NUM2DBL(rb_a);
m = NUM2DBL(rb_m);
CHECK_NUMBER(a);
CHECK_NUMBER(m);
/* a > 0 */
CHECK_POSITIVE(a);
/* m > 0 */
CHECK_POSITIVE(m);
/* a and m parameters correct */
RANDVAR_INIT(pareto);
SET_PARAM(pareto, a);
SET_PARAM(pareto, m);
CASE_END
CASE(poisson)
VALUE rb_mean;
double mean;
SET_KLASS(poisson);
rb_mean = GET_NEXT_ARG(ap);
mean = NUM2DBL(rb_mean);
CHECK_NUMBER(mean);
/* mean > 0 */
CHECK_POSITIVE(mean);
/* ensure no overflow */
if (mean > LONG_MAX - 0.05 * LONG_MAX)
rb_raise(rb_eArgError, "outcomes may overflow");
/* mean parameter correct */
RANDVAR_INIT(poisson);
SET_PARAM(poisson, mean);
CASE_END
CASE(rademacher)
SET_KLASS(rademacher);
RANDVAR_INIT(rademacher);
CASE_END
CASE(rayleigh)
VALUE rb_sigma;
double sigma;
SET_KLASS(rayleigh);
rb_sigma = GET_NEXT_ARG(ap);
sigma = NUM2DBL(rb_sigma);
CHECK_NUMBER(sigma);
/* sigma > 0 */
CHECK_POSITIVE(sigma);
RANDVAR_INIT(rayleigh);
SET_PARAM(rayleigh, sigma);
CASE_END
CASE(rectangular)
SET_KLASS(rectangular);
RANDVAR_INIT(rectangular);
CASE_END
default:
rb_rv = Qnil;
} /* switch */
va_end(ap);
return rb_rv;
}
