Annotation of /trunk/gadget/grow.cc

Parent Directory | Revision Log

---

Revision 14 - (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 :	ulcessvp	14	//replace with the function below
83 :	ulcessvp	4	///* 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 :	ulcessvp	14
154 :	agomez	1	//Same program with certain num of fish made mature.
155 :	ulcessvp	4	void AgeBandMatrix::Grow(const Matrix& Lgrowth, const Matrix& Wgrowth,
156 :			Maturity* const Mat, int area) {
157 :	agomez	1
158 :	ulcessvp	4	int i, lgrp, grow, maxlgrp, age;
159 :			double num, wt, matnum, tmp, ratio;
160 :	agomez	1
161 :	ulcessvp	4	maxlgrp = Lgrowth.Nrow();
162 :			for (i = 0; i < nrow; i++) {
163 :			int maxCol = v[i]->maxCol();
164 :			int minCol = v[i]->minCol();
165 :			age = i + minage;
166 :			num = 0.0;
167 :			wt = 0.0;
168 :			matnum = 0.0;
169 :			for (lgrp = maxCol - 1; lgrp >= maxCol - maxlgrp; lgrp--) {
170 :			for (grow = maxCol - lgrp - 1; grow < maxlgrp; grow++) {
171 :			ratio = Mat->calcMaturation(age, lgrp, grow, (*v[i])[lgrp].W);
172 :			tmp = Lgrowth[grow][lgrp] * (*v[i])[lgrp].N;
173 :			matnum += (tmp * ratio);
174 :			num += tmp;
175 :			wt += tmp * (Wgrowth[grow][lgrp] + (*v[i])[lgrp].W);
176 :			}
177 :			}
178 :	ulcessvp	2
179 :	ulcessvp	4	lgrp = maxCol - 1;
180 :			if (isZero(num) || (wt < verysmall)) {
181 :			//no fish grow to this length cell
182 :			(*v[i])[lgrp].setToZero();
183 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
184 :			} else if (isZero(matnum)) {
185 :			//none of the fish that grow to this length cell mature
186 :			(*v[i])[lgrp].W = wt / num;
187 :			(*v[i])[lgrp].N = num;
188 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
189 :			} else if (isEqual(num, matnum) || (matnum > num)) {
190 :			//all the fish that grow to this length cell mature
191 :			(*v[i])[lgrp].setToZero();
192 :			Mat->storeMatureStock(area, age, lgrp, num, wt / num);
193 :			} else {
194 :			(*v[i])[lgrp].W = wt / num;
195 :			(*v[i])[lgrp].N = num - matnum;
196 :			Mat->storeMatureStock(area, age, lgrp, matnum, wt / num);
197 :			}
198 :	agomez	1
199 :	ulcessvp	4	for (lgrp = maxCol - 2; lgrp >= minCol + maxlgrp - 1; lgrp--) {
200 :			num = 0.0;
201 :			wt = 0.0;
202 :			matnum = 0.0;
203 :			for (grow = 0; grow < maxlgrp; grow++) {
204 :			ratio = Mat->calcMaturation(age, lgrp, grow,
205 :			(*v[i])[lgrp - grow].W);
206 :			tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
207 :			matnum += (tmp * ratio);
208 :			num += tmp;
209 :			wt += tmp
210 :			* (Wgrowth[grow][lgrp - grow] + (*v[i])[lgrp - grow].W);
211 :			}
212 :	agomez	1
213 :	ulcessvp	4	if (isZero(num) || (wt < verysmall)) {
214 :			//no fish grow to this length cell
215 :			(*v[i])[lgrp].setToZero();
216 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
217 :			} else if (isZero(matnum)) {
218 :			//none of the fish that grow to this length cell mature
219 :			(*v[i])[lgrp].W = wt / num;
220 :			(*v[i])[lgrp].N = num;
221 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
222 :			} else if (isEqual(num, matnum) || (matnum > num)) {
223 :			//all the fish that grow to this length cell mature
224 :			(*v[i])[lgrp].setToZero();
225 :			Mat->storeMatureStock(area, age, lgrp, num, wt / num);
226 :			} else {
227 :			(*v[i])[lgrp].W = wt / num;
228 :			(*v[i])[lgrp].N = num - matnum;
229 :			Mat->storeMatureStock(area, age, lgrp, matnum, wt / num);
230 :			}
231 :			}
232 :	ulcessvp	2
233 :	ulcessvp	4	for (lgrp = minCol + maxlgrp - 2; lgrp >= minCol; lgrp--) {
234 :			num = 0.0;
235 :			wt = 0.0;
236 :			matnum = 0.0;
237 :			for (grow = 0; grow <= lgrp - minCol; grow++) {
238 :			ratio = Mat->calcMaturation(age, lgrp, grow,
239 :			(*v[i])[lgrp - grow].W);
240 :			tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
241 :			matnum += (tmp * ratio);
242 :			num += tmp;
243 :			wt += tmp
244 :			* (Wgrowth[grow][lgrp - grow] + (*v[i])[lgrp - grow].W);
245 :			}
246 :	agomez	1
247 :	ulcessvp	4	if (isZero(num) || (wt < verysmall)) {
248 :			//no fish grow to this length cell
249 :			(*v[i])[lgrp].setToZero();
250 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
251 :			} else if (isZero(matnum)) {
252 :			//none of the fish that grow to this length cell mature
253 :			(*v[i])[lgrp].W = wt / num;
254 :			(*v[i])[lgrp].N = num;
255 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
256 :			} else if (isEqual(num, matnum) || (matnum > num)) {
257 :			//all the fish that grow to this length cell mature
258 :			(*v[i])[lgrp].setToZero();
259 :			Mat->storeMatureStock(area, age, lgrp, num, wt / num);
260 :			} else {
261 :			(*v[i])[lgrp].W = wt / num;
262 :			(*v[i])[lgrp].N = num - matnum;
263 :			Mat->storeMatureStock(area, age, lgrp, matnum, wt / num);
264 :			}
265 :			}
266 :			}
267 :	agomez	1	}
268 :
269 :			//fleksibest formulation - weight read in from file (should be positive)
270 :	ulcessvp	4	void AgeBandMatrix::Grow(const Matrix& Lgrowth, const DoubleVector& Weight) {
271 :			int i, lgrp, grow, maxlgrp;
272 :			double num;
273 :	agomez	1
274 :	ulcessvp	4	maxlgrp = Lgrowth.Nrow();
275 :	ulcessvp	2
276 :	ulcessvp	4	for (i = 0; i < nrow; i++) {
277 :			int maxCol = v[i]->maxCol();
278 :			int minCol = v[i]->minCol();
279 :			num = 0.0;
280 :			for (lgrp = maxCol - 1; lgrp >= maxCol - maxlgrp; lgrp--)
281 :			for (grow = maxCol - lgrp - 1; grow < maxlgrp; grow++)
282 :			num += (Lgrowth[grow][lgrp] * (*v[i])[lgrp].N);
283 :	agomez	1
284 :	ulcessvp	4	lgrp = maxCol - 1;
285 :			if (isZero(num)) {
286 :			(*v[i])[lgrp].setToZero();
287 :			} else {
288 :			(*v[i])[lgrp].N = num;
289 :			(*v[i])[lgrp].W = Weight[lgrp];
290 :			}
291 :	agomez	1
292 :	ulcessvp	4	for (lgrp = maxCol - 2; lgrp >= minCol + maxlgrp - 1; lgrp--) {
293 :			num = 0.0;
294 :			for (grow = 0; grow < maxlgrp; grow++)
295 :			num += (Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N);
296 :	agomez	1
297 :	ulcessvp	4	if (isZero(num)) {
298 :			(*v[i])[lgrp].setToZero();
299 :			} else {
300 :			(*v[i])[lgrp].N = num;
301 :			(*v[i])[lgrp].W = Weight[lgrp];
302 :			}
303 :			}
304 :	agomez	1
305 :	ulcessvp	4	for (lgrp = minCol + maxlgrp - 2; lgrp >= minCol; lgrp--) {
306 :			num = 0.0;
307 :			for (grow = 0; grow <= lgrp - minCol; grow++)
308 :			num += (Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N);
309 :	agomez	1
310 :	ulcessvp	4	if (isZero(num)) {
311 :			(*v[i])[lgrp].setToZero();
312 :			} else {
313 :			(*v[i])[lgrp].N = num;
314 :			(*v[i])[lgrp].W = Weight[lgrp];
315 :			}
316 :			}
317 :			}
318 :	agomez	1	}
319 :
320 :			//fleksibest formulation - weight read in from file (should be positive)
321 :			//Same program with certain num of fish made mature.
322 :	ulcessvp	4	void AgeBandMatrix::Grow(const Matrix& Lgrowth, const DoubleVector& Weight,
323 :			Maturity* const Mat, int area) {
324 :	agomez	1
325 :	ulcessvp	4	int i, lgrp, grow, maxlgrp, age;
326 :			double num, matnum, tmp, ratio;
327 :	agomez	1
328 :	ulcessvp	4	maxlgrp = Lgrowth.Nrow();
329 :	ulcessvp	2
330 :	ulcessvp	4	for (i = 0; i < nrow; i++) {
331 :			int maxCol = v[i]->maxCol();
332 :			int minCol = v[i]->minCol();
333 :			age = i + minage;
334 :			num = 0.0;
335 :			matnum = 0.0;
336 :			for (lgrp = maxCol - 1; lgrp >= maxCol - maxlgrp; lgrp--) {
337 :			for (grow = maxCol - lgrp - 1; grow < maxlgrp; grow++) {
338 :			ratio = Mat->calcMaturation(age, lgrp, grow, (*v[i])[lgrp].W);
339 :			tmp = Lgrowth[grow][lgrp] * (*v[i])[lgrp].N;
340 :			matnum += (tmp * ratio);
341 :			num += tmp;
342 :			}
343 :			}
344 :	agomez	1
345 :	ulcessvp	4	lgrp = maxCol - 1;
346 :			if (isZero(num)) {
347 :			//no fish grow to this length cell
348 :			(*v[i])[lgrp].setToZero();
349 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
350 :			} else if (isZero(matnum)) {
351 :			//none of the fish that grow to this length cell mature
352 :			(*v[i])[lgrp].W = Weight[lgrp];
353 :			(*v[i])[lgrp].N = num;
354 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
355 :			} else if (isEqual(num, matnum) || (matnum > num)) {
356 :			//all the fish that grow to this length cell mature
357 :			(*v[i])[lgrp].setToZero();
358 :			Mat->storeMatureStock(area, age, lgrp, num, Weight[lgrp]);
359 :			} else {
360 :			(*v[i])[lgrp].W = Weight[lgrp];
361 :			(*v[i])[lgrp].N = num - matnum;
362 :			Mat->storeMatureStock(area, age, lgrp, matnum, Weight[lgrp]);
363 :			}
364 :	agomez	1
365 :	ulcessvp	4	for (lgrp = maxCol - 2; lgrp >= minCol + maxlgrp - 1; lgrp--) {
366 :			num = 0.0;
367 :			matnum = 0.0;
368 :			for (grow = 0; grow < maxlgrp; grow++) {
369 :			ratio = Mat->calcMaturation(age, lgrp, grow,
370 :			(*v[i])[lgrp - grow].W);
371 :			tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
372 :			matnum += (tmp * ratio);
373 :			num += tmp;
374 :			}
375 :	agomez	1
376 :	ulcessvp	4	if (isZero(num)) {
377 :			//no fish grow to this length cell
378 :			(*v[i])[lgrp].setToZero();
379 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
380 :			} else if (isZero(matnum)) {
381 :			//none of the fish that grow to this length cell mature
382 :			(*v[i])[lgrp].W = Weight[lgrp];
383 :			(*v[i])[lgrp].N = num;
384 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
385 :			} else if (isEqual(num, matnum) || (matnum > num)) {
386 :			//all the fish that grow to this length cell mature
387 :			(*v[i])[lgrp].setToZero();
388 :			Mat->storeMatureStock(area, age, lgrp, num, Weight[lgrp]);
389 :			} else {
390 :			(*v[i])[lgrp].W = Weight[lgrp];
391 :			(*v[i])[lgrp].N = num - matnum;
392 :			Mat->storeMatureStock(area, age, lgrp, matnum, Weight[lgrp]);
393 :			}
394 :			}
395 :	agomez	1
396 :	ulcessvp	4	for (lgrp = minCol + maxlgrp - 2; lgrp >= minCol; lgrp--) {
397 :			num = 0.0;
398 :			matnum = 0.0;
399 :			for (grow = 0; grow <= lgrp - minCol; grow++) {
400 :			ratio = Mat->calcMaturation(age, lgrp, grow,
401 :			(*v[i])[lgrp - grow].W);
402 :			tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
403 :			matnum += (tmp * ratio);
404 :			num += tmp;
405 :			}
406 :	agomez	1
407 :	ulcessvp	4	if (isZero(num)) {
408 :			//no fish grow to this length cell
409 :			(*v[i])[lgrp].setToZero();
410 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
411 :			} else if (isZero(matnum)) {
412 :			//none of the fish that grow to this length cell mature
413 :			(*v[i])[lgrp].W = Weight[lgrp];
414 :			(*v[i])[lgrp].N = num;
415 :			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
416 :			} else if (isEqual(num, matnum) || (matnum > num)) {
417 :			//all the fish that grow to this length cell mature
418 :			(*v[i])[lgrp].setToZero();
419 :			Mat->storeMatureStock(area, age, lgrp, num, Weight[lgrp]);
420 :			} else {
421 :			(*v[i])[lgrp].W = Weight[lgrp];
422 :			(*v[i])[lgrp].N = num - matnum;
423 :			Mat->storeMatureStock(area, age, lgrp, matnum, Weight[lgrp]);
424 :			}
425 :			}
426 :			}
427 :	agomez	1	}

---

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