void verify_node(KmerNode * node, KmerGraph *hashtable, unsigned kmer_length)
{
int double_kmer_length = kmer_length << 1;
#ifdef LARGE_KMERS
Kmer mask;
mask.createMask(double_kmer_length);
#else
Kmer mask = (Kmer(1) << double_kmer_length) - 1;
#endif
Kmer kmer = node->kmer;
Kmer rc_kmer = reverseComplement(kmer, kmer_length);
char rightmost_base = KMER_GET_TAIL_BASE(kmer, kmer_length);
char leftmost_base = KMER_GET_HEAD_BASE(kmer, kmer_length);
KmerNode *node2;
for (int i = 0 ; i < 4 ; ++ i) {
// check on the left side
int count = node->left_count[i];
int color = node->left_color[i];
assert( color == 0 || count != 0 ); // count must be non-zero if color is non-zero
if (color == 0) {
if (count > 0) {
Kmer kmer2 = KMER_PREPEND(kmer, i, double_kmer_length, mask);
node2 = hashtable->findNode(canonicalKmer(kmer2, kmer_length));
assert( node2 != NULL );
assert(cnorm(node2->right_count[static_cast<int>(rightmost_base)]) == cnorm(count));
assert(node2->right_color[static_cast<int>(rightmost_base)] == 0);
} else if (count < 0) {
Kmer kmer2 = KMER_APPEND(rc_kmer, i ^ 0x3, double_kmer_length);
node2 = hashtable->findNode(canonicalKmer(kmer2, kmer_length));
assert( node2 != NULL );
assert(cnorm(node2->left_count[static_cast<int>( COMPLEMENT(rightmost_base) )]) == cnorm(count));
assert(node2->left_color[static_cast<int>( COMPLEMENT(rightmost_base) )] == 0);
}
}
// check on the right side
count = node->right_count[i];
color = node->right_color[i];
assert( color == 0 || count != 0 ); // count must be non-zero if color is non-zero
if (color == 0) {
if (count > 0) {
Kmer kmer2 = KMER_APPEND(kmer, i, double_kmer_length);
node2 = hashtable->findNode(canonicalKmer(kmer2, kmer_length));
assert( node2 != NULL );
assert(cnorm(node2->left_count[static_cast<int>(leftmost_base)]) == cnorm(count));
assert(node2->left_color[static_cast<int>(leftmost_base)] == 0);
} else if (count < 0) {
Kmer kmer2 = KMER_PREPEND(rc_kmer, i ^ 0x3, double_kmer_length, mask);
node2 = hashtable->findNode(canonicalKmer(kmer2, kmer_length));
assert( node2 != NULL );
assert(cnorm(node2->right_count[static_cast<int>( COMPLEMENT(leftmost_base) )]) == cnorm(count));
assert(node2->right_color[static_cast<int>( COMPLEMENT(leftmost_base) )] == 0);
}
}
}
}
int main()
{
complex temp, z, prod;
double radius;
FILE *outfile;
int n;
char filename[100];
temp.re = 1.0; temp.im = .05;
z = rdiv(temp,cnorm(temp));
prod.re = 1.0; prod.im = 0.0;
printf("Enter radius parameter:\n");
scanf("%lf", &radius);
printf("radius = %f\n", radius);
z = rmul(radius,z);
sprintf(filename,"cmultest_r%.2f.dat", radius);
printf("Data stored in %s\n", filename);
outfile = fopen(filename, "w");
for(n=0; n<120; n++)
{
fprintf(outfile,"%f\t%f\n", prod.re, prod.im); /* print results */
prod = cmul(prod, z);
}
return(0);
}
static int circle(bool print)
{
int angle_updates[ITERATIONS + 1];
build_angle_updates(angle_updates);
#define NUM (2048)
#define SNUM (NUM / 2 + 1)
double var = 0;
double mean = 0;
static double errors[NUM];
static complex spectrum[SNUM];
fftw_plan plan = fftw_plan_dft_r2c_1d(NUM, errors, spectrum, 0);
for (int i = 0; i != NUM; ++i) {
double angle = (i + drand48()) * (2 * M_PI / NUM);
assert (0 < angle && angle < 2 * M_PI);
word_t qq = CMASK((long) floor(cos(angle) * (1l << 32)));
word_t ii = CMASK((long) floor(sin(angle) * (1l << 32)));
double err = terror(qq, ii, angle_updates);
errors[i] = err;
var += err * err;
mean += err;
if (print)
printf("%5i % .2f\n", i, err);
}
mean /= NUM;
var = var / NUM - mean * mean;
fprintf(stderr, "Mean = %f, var = %f, std. dev. = %f\n",
mean, var, sqrt(var));
//fftw_execute_dft_r2c(plan, errors, spectrum);
fftw_execute(plan);
static enum_double power[SNUM];
for (int i = 1; i != SNUM; ++i)
power[i] = (enum_double) { i, cnorm(spectrum[i]) };
qsort(power, SNUM - 1, sizeof(enum_double), compare_enum_double);
fprintf(stderr, "Harmonic Amplitude Real Imaginary\n");
for (int i = 0; i != 10; ++i) {
int index = power[i].index;
fprintf(stderr, " %7i %8.4f%% % f % f\n",
index, sqrt(power[i].value) * (100.0 / NUM),
creal(spectrum[index]),
cimag(spectrum[index]));
}
fftw_destroy_plan(plan);
fftw_cleanup();
return 0;
}
void model_parameters::initialization(void)
{
NAreaAge.initialize();
CatchAreaAge.initialize();
CatchNatAge.initialize();
Nage(1,1) = So*Bo/(1+beta*Bo);
for(int i=sage+1 ; i <= nage ; i++)
{
Nage(1,i) = Nage(1,i-1) * mfexp(-za(i-1));
}
VulB(1) = elem_prod(elem_prod(Nage(1),va),wa);
SB(1) = elem_prod(Nage(1),fa)*wa/2;
tBo = Nage(1)*wa;
calcmaxpos(tBo);
varPos = maxPos*cvPos;
PosX(1) = minPos + (maxPos - minPos) * (0.5+0.5*sin(indmonth(1)*PI/6 - mo*PI/6));
VBarea(1,sarea) = VulB(1)* (cnorm(areas(sarea)+0.5,PosX(1),varPos));
for(int r=sarea+1 ; r <= narea-1 ; r++)
{
VBarea(1,r) = VulB(1)* (cnorm(areas(r)+0.5,PosX(1),varPos)-cnorm(areas(r)-0.5,PosX(1),varPos));
NAreaAge(1)(r) = elem_prod(Nage(1)(sage,nage),(cnorm(areas(r)+0.5,PosX(1),varPos)-cnorm(areas(r)-0.5,PosX(1),varPos)));
}
//VBarea(1,narea) = VulB(1)* (1.0-cnorm(areas(narea)-0.5,PosX(1),varPos));
NationVulB(1,1) = sum(VBarea(1)(sarea,sarea+nationareas(1)-1));
NationVulB(1,2) = sum(VBarea(1)(sarea+nationareas(1),narea));
dvar_vector tmp1(sarea,narea);
dvar_vector tmp2(sarea,narea);
dvar_vector tmp3(sarea,narea);
for(int rr= sarea; rr<=narea; rr++)
{
tmp1(rr)= VBarea(1)(rr)/ (NationVulB(1)(indnatarea(rr)) + 0.0001);
tmp2(rr) = tmp1(rr)*TotEffyear(indnatarea(rr))(indyr(1));
Effarea(1)(rr) = tmp2(rr)*TotEffmonth(indnatarea(rr))(indmonth(1));
}
for(int a= sage; a<= nage;a++)
{
dvar_vector propVBarea(sarea,narea);
for(int rr =sarea; rr<=narea; rr++)
{
propVBarea(rr) = (cnorm(areas(rr)+0.5,PosX(1),varPos)-cnorm(areas(rr)-0.5,PosX(1),varPos))(a-sage+1);
CatchAreaAge(1)(rr)(a) = q*Effarea(1)(rr)*va(a)/(q*Effarea(1)(rr)*va(a)+m)*(1-mfexp(-(q*Effarea(1)(rr)*va(a)+m)))*NAreaAge(1)(rr)(a);
CatchNatAge(1)(indnatarea(rr))(a) += CatchAreaAge(1)(rr)(a);
EffNatAge(indnatarea(rr))(1)(sage-2) = 1;
EffNatAge(indnatarea(rr))(1)(sage-1) = indnatarea(rr);
EffNatAge(indnatarea(rr))(1)(a) += Effarea(1)(rr)*propVBarea(rr);
}
//cout<<"propVBarea "<<propVBarea<<endl;
//cout<<"Effarea(1) "<<Effarea(1)<<endl;
Effage(1)(a) = Effarea(1)* propVBarea;
}
}
void field_outputAllDataComplex(const char *fileName, double complex *data)
{
printf("output all data start\n");
//file open
FILE *fp;
if( (fp=fopen(fileName, "w") ) == NULL){
printf("cannot open file %s \n", fileName);
exit(2);
}
for(int i=0; i<N_PX; i++){
for(int j=0; j<N_PY; j++){
fprintf(fp, "%lf \n",cnorm(data[ind(i,j)]));
}
}
fclose(fp);
printf("output all data to %s end\n", fileName);
}
void field_outputElliptic(const char *fileName, double complex* data)
{
printf("output start\n");
//file open
FILE *fp;
if( (fp=fopen(fileName, "w") ) == NULL){
printf("cannot open file %s \n", fileName);
exit(2);
}
for(int ang=180; ang >=0; ang--){
double rad = ang*M_PI/180.0;
double x = 1.2*lambda_s*cos(rad)+N_PX/2.0;
double y = 1.2*lambda_s*sin(rad)+N_PY/2.0;
double norm = cnorm(cbilinear(data,x,y,N_PX,N_PY));
fprintf(fp, "%d %lf \n", ang, norm);
}
fclose(fp);
printf("output to %s end\n", fileName);
}
void cow_fft_pspecvecfield(cow_dfield *f, cow_histogram *hist)
// -----------------------------------------------------------------------------
// This function computes the spherically integrated power spectrum of the
// vector field represented in `f`. The user needs to supply a half-initialized
// histogram, which has not yet been committed. This function will commit,
// populate, and seal the histogram by doing the FFT's on the vector field
// components. The supplies the fields like in the example below, all other will
// be over-written.
//
// cow_histogram_setnbins(hist, 0, 256);
// cow_histogram_setspacing(hist, COW_HIST_SPACING_LINEAR); // or LOG
// cow_histogram_setnickname(hist, "mypspec"); // optional
//
// -----------------------------------------------------------------------------
{
#if (COW_FFTW)
if (!f->committed) return;
if (f->n_members != 3) {
printf("[%s] error: need a 3-component field for %s", MODULE, __FUNCTION__);
return;
}
clock_t start = clock();
int nx = cow_domain_getnumlocalzonesinterior(f->domain, 0);
int ny = cow_domain_getnumlocalzonesinterior(f->domain, 1);
int nz = cow_domain_getnumlocalzonesinterior(f->domain, 2);
int Nx = cow_domain_getnumglobalzones(f->domain, 0);
int Ny = cow_domain_getnumglobalzones(f->domain, 1);
int Nz = cow_domain_getnumglobalzones(f->domain, 2);
int ng = cow_domain_getguard(f->domain);
int ntot = nx * ny * nz;
int I0[3] = { ng, ng, ng };
int I1[3] = { nx + ng, ny + ng, nz + ng };
double norm = pow(cow_domain_getnumglobalzones(f->domain, COW_ALL_DIMS), 2.0);
double *input = (double*) malloc(3 * ntot * sizeof(double));
cow_dfield_extract(f, I0, I1, input);
FFT_DATA *gx = _fwd(f->domain, input, 0, 3); // start, stride
FFT_DATA *gy = _fwd(f->domain, input, 1, 3);
FFT_DATA *gz = _fwd(f->domain, input, 2, 3);
free(input);
cow_histogram_setlower(hist, 0, 1.0);
cow_histogram_setupper(hist, 0, 0.5*sqrt(Nx*Nx + Ny*Ny + Nz*Nz));
cow_histogram_setbinmode(hist, COW_HIST_BINMODE_DENSITY);
cow_histogram_setdomaincomm(hist, f->domain);
cow_histogram_commit(hist);
for (int i=0; i<nx; ++i) {
for (int j=0; j<ny; ++j) {
for (int k=0; k<nz; ++k) {
int m = i*ny*nz + j*nz + k;
double kvec[3];
double khat[3];
khat_at(f->domain, i, j, k, khat);
// ---------------------------------------------------------------------
// Here we are taking the complex norm (absolute value squared) of the
// vector-valued Fourier amplitude corresponding to the wave-vector, k.
//
// P(k) = |\vec{f}_\vec{k}|^2
//
// ---------------------------------------------------------------------
double Kijk = k_at(f->domain, i, j, k, kvec);
double Pijk = cnorm(gx[m]) + cnorm(gy[m]) + cnorm(gz[m]);
cow_histogram_addsample1(hist, Kijk, Pijk/norm);
}
}
}
cow_histogram_seal(hist);
free(gx);
free(gy);
free(gz);
printf("[%s] %s took %3.2f seconds\n",
MODULE, __FUNCTION__, (double) (clock() - start) / CLOCKS_PER_SEC);
#endif // COW_FFTW
}
// we know that this "node" is a node that has either no neighbors on
// one side -or- connects to a chain of nodes that leads to a single node.
static bool
check_for_tip_removal(SeqGraph *graph, SeqNode *node, bool moving_right, bool singlecopy_tip, unsigned length)
{
// XXX: performance optimization not correctness, right?
#ifdef VELOUR_TBB
if (atomic_isNodeDead<SeqNode>(node)) { return false; }
#else
if (isNodeDead<SeqNode>(node)) { return false; }
#endif
length += node->sequence.get_length() - g__FULLKMER_LENGTH + 1;
singlecopy_tip &= (isNodeWeight_None(node) || isNodeWeight_AllSingleCopy(node));
if (length >= TIP_REMOVAL_LENGTH && !singlecopy_tip) { // FIXME? singlecopy_tip might be incorrect as didn't consider forward arc???
return false; // can't remove a tip that is too long
}
// find out if this tip can be extended. This has two conditions:
// CONDITION 1: there is a single neighbor in the extension direction
#ifdef VELOUR_TBB
union {
counter_t count[4];
four_counter_t side;
} local_counters;
local_counters.side = moving_right ? ATOMIC_LOAD(node->right_side) : ATOMIC_LOAD(node->left_side);
counter_t *counters = local_counters.count;
#else
counter_t *counters = moving_right ? node->right_count : node->left_count;
#endif
int valid_dir = valid_single_successor(counters);
if (valid_dir == MULTIPLE_SUCCESSORS) {
return false; // can't remove a tip with two outgrowths (the base of a Y)
}
if (valid_dir == NO_SUCCESSORS) {
#ifdef VELOUR_TBB
atomic_setNodeDead<SeqNode>(node);
ATOMIC_STORE(node->connections) = 0;
ATOMIC_STORE(node->left_side_colors) = 0;
ATOMIC_STORE(node->right_side_colors) = 0;
ATOMIZE(DISCONNECTED_CHUNKS).fetch_and_increment();
#else
setNodeDead<SeqNode>(node);
node->connections = 0;
node->left_side_colors = 0;
node->right_side_colors = 0;
++ DISCONNECTED_CHUNKS;
#endif
// printf("a disconnected chunk of length %d\n", length);
return true;
}
// a single successor
// CONDITION 2: the node in the extension direction has a single
// neighbor in the direction facing this node
assert((valid_dir >= 0) && (valid_dir < 4));
bool sense_changed;
#ifdef VELOUR_TBB
union {
color_t color[4];
four_color_t side;
} local_colors;
local_colors.side = moving_right ? ATOMIC_LOAD(node->right_side_colors) : ATOMIC_LOAD(node->left_side_colors);
color_t *colors = local_colors.color;
#else
color_t *colors = moving_right ? node->right_color : node->left_color;
#endif
SeqNode *next = NULL;
if (colors[valid_dir] == 0) {
next = graph->findNextNode(node, valid_dir, moving_right, &sense_changed);
} else {
return false;
}
assert( next != NULL );
bool next_moving_right = moving_right ^ sense_changed;
#ifdef VELOUR_TBB
union {
counter_t count[4];
four_counter_t side;
} local_back_counters;
local_back_counters.side = next_moving_right ? ATOMIC_LOAD(next->left_side) : ATOMIC_LOAD(next->right_side);
counter_t *next_back_counters = local_back_counters.count;
#else
counter_t *next_back_counters = next_moving_right ? next->left_count : next->right_count;
#endif
int next_back_valid = valid_single_successor(next_back_counters);
if (next_back_valid != MULTIPLE_SUCCESSORS) {
bool forceclip = (abs(next_back_counters[next_back_valid]) == CLIP_SINGLECOPY_COUNTER_VALUE);
singlecopy_tip &= cnorm(counters[valid_dir]) == 1;
bool remove = check_for_tip_removal(graph, next, next_moving_right, singlecopy_tip, length);
if (remove || singlecopy_tip || forceclip) {
#ifdef VELOUR_TBB
atomic_setNodeDead<SeqNode>(node);
ATOMIC_STORE(node->connections) = 0;
ATOMIC_STORE(node->left_side_colors) = 0;
ATOMIC_STORE(node->right_side_colors) = 0;
#else
setNodeDead<SeqNode>(node);
node->connections = 0;
node->left_side_colors = 0;
node->right_side_colors = 0;
#endif
}
if (!remove && (singlecopy_tip || forceclip)) {
#ifdef VELOUR_TBB
ATOMIC_STORE( (next_moving_right ? next->left_count : next->right_count)[next_back_valid] ) = 0;
ATOMIC_STORE( (next_moving_right?next->left_color:next->right_color)[next_back_valid] ) = 0;
#else
next_back_counters[next_back_valid] = 0;
(next_moving_right?next->left_color:next->right_color)[next_back_valid] = 0;
#endif
}
return remove || singlecopy_tip || forceclip;
}
// can't extend. Need to determine if we should trim.
counter_t max_value = get_counter_max(next_back_counters);
counter_t value = abs(counters[valid_dir]);
if (value == CLIP_SINGLECOPY_COUNTER_VALUE) value = 1;
if ((value >= g_minimum_edge_weight) && (value == max_value)) {
// printf("dominant connection: length %d, weight %d\n", length, abs(counters[valid_dir]));
return false; // can't remove the dominant connection
}
// check for multiple single-copy predecessors in next node; mark those arcs as potential clips
if (value == 1 && value == max_value) {
for (int i = 0 ; i < 4 ; ++ i) {
if (next_back_counters[i] == 1) {
#ifdef VELOUR_TBB
ATOMIC_STORE( (next_moving_right ? next->left_count : next->right_count)[i] ) = CLIP_SINGLECOPY_COUNTER_VALUE;
#else
next_back_counters[i] = CLIP_SINGLECOPY_COUNTER_VALUE;
#endif
} else if (next_back_counters[i] == -1) {
#ifdef VELOUR_TBB
ATOMIC_STORE( (next_moving_right ? next->left_count : next->right_count)[i] ) = - CLIP_SINGLECOPY_COUNTER_VALUE;
#else
next_back_counters[i] = - CLIP_SINGLECOPY_COUNTER_VALUE;
#endif
}
}
}
// if we are clipping the tip, then mark the current "node" for
// removal and disconnect the "next" node from the tip.
/*
#ifdef VERIFY
verify_node(node, HASHTABLE, g__FULLKMER_LENGTH); // FINE, BEFORE WE LET IT GET INCONSISTENT.
verify_node(next, HASHTABLE, g__FULLKMER_LENGTH);
#endif
*/
// Note: we remove the link from "next", but not from "node". The
// reason why is that we don't want code to start on the other side
// thinking that it is a tip that might need removal. This means
// that from "node's" perspective, the graph looks inconsistent, but
// that is okay, since we're going to remove "node" shortly.
#ifdef VELOUR_TBB
atomic_setNodeDead<SeqNode>(node);
ATOMIC_STORE(node->connections) = 0;
ATOMIC_STORE(node->left_side_colors) = 0;
ATOMIC_STORE(node->right_side_colors) = 0;
#else
setNodeDead<SeqNode>(node);
node->connections = 0;
node->left_side_colors = 0;
node->right_side_colors = 0;
#endif
// printf("removal candidate: length %d, weight %d\n", length, abs(counters[valid_dir]));
Nucleotide head_rightmost_base = node->sequence.GetHeadKmerRightmostBase(g__FULLKMER_LENGTH);
Nucleotide tail_leftmost_base = node->sequence.GetTailKmerLeftmostBase(g__FULLKMER_LENGTH);
next_back_valid = moving_right ? tail_leftmost_base : head_rightmost_base;
if (sense_changed) { next_back_valid ^= 0x3; } // FIXME: i.e. complement??
#ifdef VELOUR_TBB
ATOMIC_STORE( (next_moving_right?next->left_color:next->right_color)[next_back_valid] ) = 0;
#else
(next_moving_right?next->left_color:next->right_color)[next_back_valid] = 0;
#endif
#ifdef VELOUR_TBB
ATOMIC_STORE( (next_moving_right ? next->left_count : next->right_count)[next_back_valid] ) = 0;
#else
next_back_counters[next_back_valid] = 0;
#endif
#ifdef VELOUR_TBB
ATOMIZE(TIP_DETACHED).fetch_and_increment();
#else
++ TIP_DETACHED;
#endif
/*
#ifdef VERIFY
// verify_node(node, g__FULLKMER_LENGTH); // THIS VALIDATION WOULD FAIL, SINCE WE DON'T MODIFY NODE
verify_node(next, HASHTABLE, g__FULLKMER_LENGTH);
#endif
*/
return true;
}
void model_parameters::move_grow_die(void)
{
dvariable tB;
for(int i=2;i<=ntstp;i++)
{
//if(i>12)exit(1);
switch (indmonth(i)) {
case 1:
Nage(i)(sage) = (So*SB(i-nmon)/(1.+beta*SB(i-nmon)))*mfexp(wt(indyr(i))*err);
for(int a = sage+1;a<=nage;a++)
{
Nage(i)(a) = Nage(i-1)(a-1)*mfexp(-(m+q*Effage(i-1)(a-1)*va(a-1))/12);
}
break;
default:
Nage(i) = elem_prod(Nage(i-1),mfexp(-(m+q*elem_prod(Effage(i-1),va))/12));
break;
}
VulB(i) = elem_prod(elem_prod(Nage(i),va),wa);
SB(i) = elem_prod(Nage(i),fa)*wa/2;
maxPos.initialize();
tB = Nage(i)*wa;
calcmaxpos(tB);
//cout<<"maxPos "<<maxPos<<endl;
varPos = maxPos*cvPos;
PosX(i) = minPos + (maxPos - minPos) * (0.5+0.5*sin(indmonth(i)*PI/6 - mo*PI/6));
VBarea(i,sarea) = VulB(i)* (cnorm(areas(sarea)+0.5,PosX(i),varPos));
for(int r = sarea+1;r <= narea;r++)
{
VBarea(i)(r) = VulB(i)* (cnorm(areas(r)+0.5,PosX(i),varPos)-cnorm(areas(r)-0.5,PosX(i),varPos));
NAreaAge(i)(r) = elem_prod(Nage(i)(sage,nage),(cnorm(areas(r)+0.5,PosX(i),varPos)-cnorm(areas(r)-0.5,PosX(i),varPos)));
}
//VBarea(i,narea) = VulB(i)* (1.0-cnorm(areas(narea)-0.5,PosX(i),varPos));
NationVulB(i,1) = sum(VBarea(i)(sarea,sarea+nationareas(1)-1));
NationVulB(i,2) = sum(VBarea(i)(sarea+nationareas(1),narea));
dvar_vector tmp1(sarea,narea);
dvar_vector tmp2(sarea,narea);
for(int rr= sarea; rr<=narea; rr++)
{
tmp1(rr)= VBarea(i)(rr)/ (NationVulB(i)(indnatarea(rr)) + 1);
tmp2(rr) = tmp1(rr)*TotEffyear(indnatarea(rr))(indyr(i));
Effarea(i)(rr) = tmp2(rr)*TotEffmonth(indnatarea(rr))(indmonth(i));
}
for(int a = sage; a<=nage;a++)
{
dvar_vector propVBarea(sarea,narea);
for(int rr =sarea; rr<=narea; rr++)
{
propVBarea(rr) = (cnorm(areas(rr)+0.5,PosX(i),varPos)-cnorm(areas(rr)-0.5,PosX(i),varPos))(a-sage+1);
EffNatAge(indnatarea(rr))(i)(sage-2) = i;
EffNatAge(indnatarea(rr))(i)(sage-1) = indnatarea(rr);
EffNatAge(indnatarea(rr))(i)(a) += Effarea(i)(rr)* propVBarea(rr);
}
//cout<<"propVBarea "<<propVBarea<<endl;
//cout<<"Effarea(1) "<<Effarea(1)<<endl;
Effage(i)(a) = Effarea(i)*propVBarea;
}
for(int r = sarea+1;r <= narea-1;r++)
{
for(int a = sage; a<=nage;a++)
{
CatchAreaAge(i)(r)(a) = q*Effarea(i)(r)*va(a)/(q*Effarea(i)(r)*va(a)+m)*(1-mfexp(-(q*Effarea(i)(r)*va(a)+m)))*NAreaAge(i)(r)(a);
CatchNatAge(i)(indnatarea(r))(a)+= CatchAreaAge(i)(r)(a);
}
}
}
}
