Annotation of /trunk/gadget/grow.cc

Parent Directory | Revision Log

---

Revision 4 - (view) (download)

1 :	agomez	1	#include "maturity.h"
2 :			#include "grower.h"
3 :			#include "agebandmatrix.h"
4 :			#include "gadget.h"
5 :	ulcessvp	2	#include "doublematrix.h"
6 :			#include "matrix.h"
7 :	agomez	1
8 :			/* Update the agebandmatrix to reflect the calculated growth */
9 :			/* Lgrowth contains the ratio of each length group that grows */
10 :			/* by a certain number of length groups, and Wgrowth contains */
11 :			/* the weight increase for each entry in Lgrowth */
12 :
13 :			/* JMB changed to deal with very small weights a bit better */
14 :	ulcessvp	4	void AgeBandMatrix::Grow(const Matrix& Lgrowth, const Matrix& Wgrowth) {
15 :			int i, lgrp, grow, maxlgrp;
16 :			double num, wt, tmp;
17 :	agomez	1
18 :	ulcessvp	4	maxlgrp = Lgrowth.Nrow();
19 :	ulcessvp	2
20 :	ulcessvp	4	for (i = 0; i < nrow; i++) {
21 :			int maxCol = v[i]->maxCol();
22 :			int minCol = v[i]->minCol();
23 :			//the part that grows to or above the highest length group
24 :			num = 0.0;
25 :			wt = 0.0;
26 :	ulcessvp	2
27 :	ulcessvp	4	for (lgrp = maxCol - 1; lgrp >= maxCol - maxlgrp; lgrp--) {
28 :			for (grow = maxCol - lgrp - 1; grow < maxlgrp; grow++) {
29 :			tmp = Lgrowth[grow][lgrp] * (*v[i])[lgrp].N;
30 :			num += tmp;
31 :			wt += tmp * (Wgrowth[grow][lgrp] + (*v[i])[lgrp].W);
32 :			}
33 :			}
34 :	ulcessvp	2
35 :	ulcessvp	4	lgrp = maxCol - 1;
36 :			if (isZero(num) || (wt < verysmall)) {
37 :			(*v[i])[lgrp].setToZero();
38 :			} else {
39 :			(*v[i])[lgrp].W = wt / num;
40 :			(*v[i])[lgrp].N = num;
41 :			}
42 :	ulcessvp	2
43 :	ulcessvp	4	//the central diagonal part of the length division
44 :			for (lgrp = maxCol - 2; lgrp >= minCol + maxlgrp - 1; lgrp--) {
45 :			num = 0.0;
46 :			wt = 0.0;
47 :			for (grow = 0; grow < maxlgrp; grow++) {
48 :			tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
49 :			num += tmp;
50 :			wt += tmp
51 :			* (Wgrowth[grow][lgrp - grow] + (*v[i])[lgrp - grow].W);
52 :			}
53 :			if (isZero(num) || (wt < verysmall)) {
54 :			(*v[i])[lgrp].setToZero();
55 :			} else {
56 :			(*v[i])[lgrp].W = wt / num;
57 :			(*v[i])[lgrp].N = num;
58 :			}
59 :			}
60 :	agomez	1
61 :	ulcessvp	4	//the lowest part of the length division
62 :			for (lgrp = minCol + maxlgrp - 2; lgrp >= minCol; lgrp--) {
63 :			num = 0.0;
64 :			wt = 0.0;
65 :			for (grow = 0; grow <= lgrp - minCol; grow++) {
66 :			tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
67 :			num += tmp;
68 :			wt += tmp
69 :			* (Wgrowth[grow][lgrp - grow] + (*v[i])[lgrp - grow].W);
70 :			}
71 :			if (isZero(num) || (wt < verysmall)) {
72 :			(*v[i])[lgrp].setToZero();
73 :			} else {
74 :			(*v[i])[lgrp].W = wt / num;
75 :			(*v[i])[lgrp].N = num;
76 :			}
77 :			}
78 :			}
79 :	agomez	1	}
80 :
81 :	ulcessvp	4	/********************************************************************************/
82 :
83 :			///* JMB changed to deal with very small weights a bit better */
84 :			//void AgeBandMatrix::Grow(const DoubleMatrix& Lgrowth,
85 :			// const DoubleMatrix& Wgrowth) {
86 :			// int i, lgrp, grow, maxlgrp;
87 :			// double num, wt, tmp;
88 :			//
89 :			// maxlgrp = Lgrowth.Nrow();
90 :			//
91 :			// for (i = 0; i < nrow; i++) {
92 :			// int maxCol = v[i]->maxCol();
93 :			// int minCol = v[i]->minCol();
94 :			// //the part that grows to or above the highest length group
95 :			// num = 0.0;
96 :			// wt = 0.0;
97 :			//
98 :			// for (lgrp = maxCol - 1; lgrp >= maxCol - maxlgrp; lgrp--) {
99 :			// for (grow = maxCol - lgrp - 1; grow < maxlgrp; grow++) {
100 :			// tmp = Lgrowth[grow][lgrp] * (*v[i])[lgrp].N;
101 :			// num += tmp;
102 :			// wt += tmp * (Wgrowth[grow][lgrp] + (*v[i])[lgrp].W);
103 :			// }
104 :			// }
105 :			//
106 :			// lgrp = maxCol - 1;
107 :			// if (isZero(num) || (wt < verysmall)) {
108 :			// (*v[i])[lgrp].setToZero();
109 :			// } else {
110 :			// (*v[i])[lgrp].W = wt / num;
111 :			// (*v[i])[lgrp].N = num;
112 :			// }
113 :			//
114 :			// //the central diagonal part of the length division
115 :			// for (lgrp = maxCol - 2; lgrp >= minCol + maxlgrp - 1; lgrp--) {
116 :			// num = 0.0;
117 :			// wt = 0.0;
118 :			// for (grow = 0; grow < maxlgrp; grow++) {
119 :			// tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
120 :			// num += tmp;
121 :			// wt += tmp
122 :			// * (Wgrowth[grow][lgrp - grow] + (*v[i])[lgrp - grow].W);
123 :			// }
124 :			//
125 :			// if (isZero(num) || (wt < verysmall)) {
126 :			// (*v[i])[lgrp].setToZero();
127 :			// } else {
128 :			// (*v[i])[lgrp].W = wt / num;
129 :			// (*v[i])[lgrp].N = num;
130 :			// }
131 :			// }
132 :			//
133 :			// //the lowest part of the length division
134 :			// for (lgrp = minCol + maxlgrp - 2; lgrp >= minCol; lgrp--) {
135 :			// num = 0.0;
136 :			// wt = 0.0;
137 :			// for (grow = 0; grow <= lgrp - minCol; grow++) {
138 :			// tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
139 :			// num += tmp;
140 :			// wt += tmp
141 :			// * (Wgrowth[grow][lgrp - grow] + (*v[i])[lgrp - grow].W);
142 :			// }
143 :			//
144 :			// if (isZero(num) || (wt < verysmall)) {
145 :			// (*v[i])[lgrp].setToZero();
146 :			// } else {
147 :			// (*v[i])[lgrp].W = wt / num;
148 :			// (*v[i])[lgrp].N = num;
149 :			// }
150 :			// }
151 :			// }
152 :			//}
153 :	agomez	1	//Same program with certain num of fish made mature.
154 :	ulcessvp	4	void AgeBandMatrix::Grow(const Matrix& Lgrowth, const Matrix& Wgrowth,
155 :			Maturity* const Mat, int area) {
156 :	agomez	1
157 :	ulcessvp	4	int i, lgrp, grow, maxlgrp, age;
158 :			double num, wt, matnum, tmp, ratio;
159 :	agomez	1
160 :	ulcessvp	4	maxlgrp = Lgrowth.Nrow();
161 :			for (i = 0; i < nrow; i++) {
162 :			int maxCol = v[i]->maxCol();
163 :			int minCol = v[i]->minCol();
164 :			age = i + minage;
165 :			num = 0.0;
166 :			wt = 0.0;
167 :			matnum = 0.0;
168 :			for (lgrp = maxCol - 1; lgrp >= maxCol - maxlgrp; lgrp--) {
169 :			for (grow = maxCol - lgrp - 1; grow < maxlgrp; grow++) {
170 :			ratio = Mat->calcMaturation(age, lgrp, grow, (*v[i])[lgrp].W);
171 :			tmp = Lgrowth[grow][lgrp] * (*v[i])[lgrp].N;
172 :			matnum += (tmp * ratio);
173 :			num += tmp;
174 :			wt += tmp * (Wgrowth[grow][lgrp] + (*v[i])[lgrp].W);
175 :			}
176 :			}
177 :	ulcessvp	2
178 :	ulcessvp	4	lgrp = maxCol - 1;
179 :			if (isZero(num) || (wt < verysmall)) {
180 :			//no fish grow to this length cell
181 :			(*v[i])[lgrp].setToZero();
182 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
183 :			} else if (isZero(matnum)) {
184 :			//none of the fish that grow to this length cell mature
185 :			(*v[i])[lgrp].W = wt / num;
186 :			(*v[i])[lgrp].N = num;
187 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
188 :			} else if (isEqual(num, matnum) || (matnum > num)) {
189 :			//all the fish that grow to this length cell mature
190 :			(*v[i])[lgrp].setToZero();
191 :			Mat->storeMatureStock(area, age, lgrp, num, wt / num);
192 :			} else {
193 :			(*v[i])[lgrp].W = wt / num;
194 :			(*v[i])[lgrp].N = num - matnum;
195 :			Mat->storeMatureStock(area, age, lgrp, matnum, wt / num);
196 :			}
197 :	agomez	1
198 :	ulcessvp	4	for (lgrp = maxCol - 2; lgrp >= minCol + maxlgrp - 1; lgrp--) {
199 :			num = 0.0;
200 :			wt = 0.0;
201 :			matnum = 0.0;
202 :			for (grow = 0; grow < maxlgrp; grow++) {
203 :			ratio = Mat->calcMaturation(age, lgrp, grow,
204 :			(*v[i])[lgrp - grow].W);
205 :			tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
206 :			matnum += (tmp * ratio);
207 :			num += tmp;
208 :			wt += tmp
209 :			* (Wgrowth[grow][lgrp - grow] + (*v[i])[lgrp - grow].W);
210 :			}
211 :	agomez	1
212 :	ulcessvp	4	if (isZero(num) || (wt < verysmall)) {
213 :			//no fish grow to this length cell
214 :			(*v[i])[lgrp].setToZero();
215 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
216 :			} else if (isZero(matnum)) {
217 :			//none of the fish that grow to this length cell mature
218 :			(*v[i])[lgrp].W = wt / num;
219 :			(*v[i])[lgrp].N = num;
220 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
221 :			} else if (isEqual(num, matnum) || (matnum > num)) {
222 :			//all the fish that grow to this length cell mature
223 :			(*v[i])[lgrp].setToZero();
224 :			Mat->storeMatureStock(area, age, lgrp, num, wt / num);
225 :			} else {
226 :			(*v[i])[lgrp].W = wt / num;
227 :			(*v[i])[lgrp].N = num - matnum;
228 :			Mat->storeMatureStock(area, age, lgrp, matnum, wt / num);
229 :			}
230 :			}
231 :	ulcessvp	2
232 :	ulcessvp	4	for (lgrp = minCol + maxlgrp - 2; lgrp >= minCol; lgrp--) {
233 :			num = 0.0;
234 :			wt = 0.0;
235 :			matnum = 0.0;
236 :			for (grow = 0; grow <= lgrp - minCol; grow++) {
237 :			ratio = Mat->calcMaturation(age, lgrp, grow,
238 :			(*v[i])[lgrp - grow].W);
239 :			tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
240 :			matnum += (tmp * ratio);
241 :			num += tmp;
242 :			wt += tmp
243 :			* (Wgrowth[grow][lgrp - grow] + (*v[i])[lgrp - grow].W);
244 :			}
245 :	agomez	1
246 :	ulcessvp	4	if (isZero(num) || (wt < verysmall)) {
247 :			//no fish grow to this length cell
248 :			(*v[i])[lgrp].setToZero();
249 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
250 :			} else if (isZero(matnum)) {
251 :			//none of the fish that grow to this length cell mature
252 :			(*v[i])[lgrp].W = wt / num;
253 :			(*v[i])[lgrp].N = num;
254 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
255 :			} else if (isEqual(num, matnum) || (matnum > num)) {
256 :			//all the fish that grow to this length cell mature
257 :			(*v[i])[lgrp].setToZero();
258 :			Mat->storeMatureStock(area, age, lgrp, num, wt / num);
259 :			} else {
260 :			(*v[i])[lgrp].W = wt / num;
261 :			(*v[i])[lgrp].N = num - matnum;
262 :			Mat->storeMatureStock(area, age, lgrp, matnum, wt / num);
263 :			}
264 :			}
265 :			}
266 :	agomez	1	}
267 :
268 :			//fleksibest formulation - weight read in from file (should be positive)
269 :	ulcessvp	4	void AgeBandMatrix::Grow(const Matrix& Lgrowth, const DoubleVector& Weight) {
270 :			int i, lgrp, grow, maxlgrp;
271 :			double num;
272 :	agomez	1
273 :	ulcessvp	4	maxlgrp = Lgrowth.Nrow();
274 :	ulcessvp	2
275 :	ulcessvp	4	for (i = 0; i < nrow; i++) {
276 :			int maxCol = v[i]->maxCol();
277 :			int minCol = v[i]->minCol();
278 :			num = 0.0;
279 :			for (lgrp = maxCol - 1; lgrp >= maxCol - maxlgrp; lgrp--)
280 :			for (grow = maxCol - lgrp - 1; grow < maxlgrp; grow++)
281 :			num += (Lgrowth[grow][lgrp] * (*v[i])[lgrp].N);
282 :	agomez	1
283 :	ulcessvp	4	lgrp = maxCol - 1;
284 :			if (isZero(num)) {
285 :			(*v[i])[lgrp].setToZero();
286 :			} else {
287 :			(*v[i])[lgrp].N = num;
288 :			(*v[i])[lgrp].W = Weight[lgrp];
289 :			}
290 :	agomez	1
291 :	ulcessvp	4	for (lgrp = maxCol - 2; lgrp >= minCol + maxlgrp - 1; lgrp--) {
292 :			num = 0.0;
293 :			for (grow = 0; grow < maxlgrp; grow++)
294 :			num += (Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N);
295 :	agomez	1
296 :	ulcessvp	4	if (isZero(num)) {
297 :			(*v[i])[lgrp].setToZero();
298 :			} else {
299 :			(*v[i])[lgrp].N = num;
300 :			(*v[i])[lgrp].W = Weight[lgrp];
301 :			}
302 :			}
303 :	agomez	1
304 :	ulcessvp	4	for (lgrp = minCol + maxlgrp - 2; lgrp >= minCol; lgrp--) {
305 :			num = 0.0;
306 :			for (grow = 0; grow <= lgrp - minCol; grow++)
307 :			num += (Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N);
308 :	agomez	1
309 :	ulcessvp	4	if (isZero(num)) {
310 :			(*v[i])[lgrp].setToZero();
311 :			} else {
312 :			(*v[i])[lgrp].N = num;
313 :			(*v[i])[lgrp].W = Weight[lgrp];
314 :			}
315 :			}
316 :			}
317 :	agomez	1	}
318 :
319 :			//fleksibest formulation - weight read in from file (should be positive)
320 :			//Same program with certain num of fish made mature.
321 :	ulcessvp	4	void AgeBandMatrix::Grow(const Matrix& Lgrowth, const DoubleVector& Weight,
322 :			Maturity* const Mat, int area) {
323 :	agomez	1
324 :	ulcessvp	4	int i, lgrp, grow, maxlgrp, age;
325 :			double num, matnum, tmp, ratio;
326 :	agomez	1
327 :	ulcessvp	4	maxlgrp = Lgrowth.Nrow();
328 :	ulcessvp	2
329 :	ulcessvp	4	for (i = 0; i < nrow; i++) {
330 :			int maxCol = v[i]->maxCol();
331 :			int minCol = v[i]->minCol();
332 :			age = i + minage;
333 :			num = 0.0;
334 :			matnum = 0.0;
335 :			for (lgrp = maxCol - 1; lgrp >= maxCol - maxlgrp; lgrp--) {
336 :			for (grow = maxCol - lgrp - 1; grow < maxlgrp; grow++) {
337 :			ratio = Mat->calcMaturation(age, lgrp, grow, (*v[i])[lgrp].W);
338 :			tmp = Lgrowth[grow][lgrp] * (*v[i])[lgrp].N;
339 :			matnum += (tmp * ratio);
340 :			num += tmp;
341 :			}
342 :			}
343 :	agomez	1
344 :	ulcessvp	4	lgrp = maxCol - 1;
345 :			if (isZero(num)) {
346 :			//no fish grow to this length cell
347 :			(*v[i])[lgrp].setToZero();
348 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
349 :			} else if (isZero(matnum)) {
350 :			//none of the fish that grow to this length cell mature
351 :			(*v[i])[lgrp].W = Weight[lgrp];
352 :			(*v[i])[lgrp].N = num;
353 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
354 :			} else if (isEqual(num, matnum) || (matnum > num)) {
355 :			//all the fish that grow to this length cell mature
356 :			(*v[i])[lgrp].setToZero();
357 :			Mat->storeMatureStock(area, age, lgrp, num, Weight[lgrp]);
358 :			} else {
359 :			(*v[i])[lgrp].W = Weight[lgrp];
360 :			(*v[i])[lgrp].N = num - matnum;
361 :			Mat->storeMatureStock(area, age, lgrp, matnum, Weight[lgrp]);
362 :			}
363 :	agomez	1
364 :	ulcessvp	4	for (lgrp = maxCol - 2; lgrp >= minCol + maxlgrp - 1; lgrp--) {
365 :			num = 0.0;
366 :			matnum = 0.0;
367 :			for (grow = 0; grow < maxlgrp; grow++) {
368 :			ratio = Mat->calcMaturation(age, lgrp, grow,
369 :			(*v[i])[lgrp - grow].W);
370 :			tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
371 :			matnum += (tmp * ratio);
372 :			num += tmp;
373 :			}
374 :	agomez	1
375 :	ulcessvp	4	if (isZero(num)) {
376 :			//no fish grow to this length cell
377 :			(*v[i])[lgrp].setToZero();
378 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
379 :			} else if (isZero(matnum)) {
380 :			//none of the fish that grow to this length cell mature
381 :			(*v[i])[lgrp].W = Weight[lgrp];
382 :			(*v[i])[lgrp].N = num;
383 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
384 :			} else if (isEqual(num, matnum) || (matnum > num)) {
385 :			//all the fish that grow to this length cell mature
386 :			(*v[i])[lgrp].setToZero();
387 :			Mat->storeMatureStock(area, age, lgrp, num, Weight[lgrp]);
388 :			} else {
389 :			(*v[i])[lgrp].W = Weight[lgrp];
390 :			(*v[i])[lgrp].N = num - matnum;
391 :			Mat->storeMatureStock(area, age, lgrp, matnum, Weight[lgrp]);
392 :			}
393 :			}
394 :	agomez	1
395 :	ulcessvp	4	for (lgrp = minCol + maxlgrp - 2; lgrp >= minCol; lgrp--) {
396 :			num = 0.0;
397 :			matnum = 0.0;
398 :			for (grow = 0; grow <= lgrp - minCol; grow++) {
399 :			ratio = Mat->calcMaturation(age, lgrp, grow,
400 :			(*v[i])[lgrp - grow].W);
401 :			tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
402 :			matnum += (tmp * ratio);
403 :			num += tmp;
404 :			}
405 :	agomez	1
406 :	ulcessvp	4	if (isZero(num)) {
407 :			//no fish grow to this length cell
408 :			(*v[i])[lgrp].setToZero();
409 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
410 :			} else if (isZero(matnum)) {
411 :			//none of the fish that grow to this length cell mature
412 :			(*v[i])[lgrp].W = Weight[lgrp];
413 :			(*v[i])[lgrp].N = num;
414 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
415 :			} else if (isEqual(num, matnum) || (matnum > num)) {
416 :			//all the fish that grow to this length cell mature
417 :			(*v[i])[lgrp].setToZero();
418 :			Mat->storeMatureStock(area, age, lgrp, num, Weight[lgrp]);
419 :			} else {
420 :			(*v[i])[lgrp].W = Weight[lgrp];
421 :			(*v[i])[lgrp].N = num - matnum;
422 :			Mat->storeMatureStock(area, age, lgrp, matnum, Weight[lgrp]);
423 :			}
424 :			}
425 :			}
426 :	agomez	1	}

---

root@forge.cesga.es	ViewVC Help
Powered by ViewVC 1.0.0