--- trunk/gadget/grow.cc	2015/04/29 12:55:30	2
+++ trunk/gadget/grow.cc	2015/04/30 17:32:47	4
@@ -10,438 +10,417 @@
 /* by a certain number of length groups, and Wgrowth contains */
 /* the weight increase for each entry in Lgrowth              */
 
-
-  void AgeBandMatrix::Grow(const Matrix& Lgrowth, const Matrix& Wgrowth) {
-    int i, lgrp, grow, maxlgrp;
-    double num, wt, tmp;
-//    ofstream outfile;
-//      outfile.open("aaa", ios::out);
-//    _Lgrowth.Print(outfile);
-//    int a;
-//    cout << "1-----------------" << endl;
-//    cin >> a;
-
-
-    maxlgrp = Lgrowth.Nrow();
-
-
-  //   double** lGrowth = ToMatrix(Lgrowth, maxlgrp, aux);
-  //   double** wGrowth = ToMatrix(Wgrowth, maxlgrp, aux);
-
-
-    for (i = 0; i < nrow; i++) {
-  	int maxCol = v[i]->maxCol();
-  	int minCol = v[i]->minCol();
-      //the part that grows to or above the highest length group
-      num = 0.0;
-      wt = 0.0;
-
-      for (lgrp = maxCol - 1; lgrp >= maxCol - maxlgrp; lgrp--) {
-        for (grow = maxCol - lgrp - 1; grow < maxlgrp; grow++) {
-          tmp = Lgrowth[grow][lgrp] * (*v[i])[lgrp].N;
-          num += tmp;
-          wt += tmp * (Wgrowth[grow][lgrp] + (*v[i])[lgrp].W);
-        }
-      }
-//      cout << "wt1:" << wt << endl;
-
-      lgrp = maxCol - 1;
-      if (isZero(num) || (wt < verysmall)) {
-        (*v[i])[lgrp].setToZero();
-      } else {
-        (*v[i])[lgrp].W = wt / num;
-        (*v[i])[lgrp].N = num;
-      }
-
-
-      //the central diagonal part of the length division
-      for (lgrp = maxCol - 2; lgrp >= minCol + maxlgrp - 1; lgrp--) {
-        num = 0.0;
-        wt = 0.0;
-        for (grow = 0; grow < maxlgrp; grow++) {
-          tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
-          num += tmp;
-          wt += tmp * (Wgrowth[grow][lgrp - grow] + (*v[i])[lgrp - grow].W);
-        }
-//        cout << "wt2:" << wt << endl;
-        if (isZero(num) || (wt < verysmall)) {
-          (*v[i])[lgrp].setToZero();
-        } else {
-          (*v[i])[lgrp].W = wt / num;
-          (*v[i])[lgrp].N = num;
-        }
-      }
-
-
-      //the lowest part of the length division
-      for (lgrp = minCol + maxlgrp - 2; lgrp >= minCol; lgrp--) {
-        num = 0.0;
-        wt = 0.0;
-        for (grow = 0; grow <= lgrp - minCol; grow++) {
-          tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
-          num += tmp;
-          wt += tmp * (Wgrowth[grow][lgrp - grow] + (*v[i])[lgrp - grow].W);
-        }
-
-        if (isZero(num) || (wt < verysmall)) {
-          (*v[i])[lgrp].setToZero();
-        } else {
-          (*v[i])[lgrp].W = wt / num;
-          (*v[i])[lgrp].N = num;
-        }
-      }
-//      cout << "wt3:" << wt << endl;
-    }
-  }
-
-
-
-
-
-
-
-
-
-  /********************************************************************************/
-
 /* JMB changed to deal with very small weights a bit better   */
-void AgeBandMatrix::Grow(const DoubleMatrix& Lgrowth, const DoubleMatrix& Wgrowth) {
-  int i, lgrp, grow, maxlgrp;
-  double num, wt, tmp;
-
-  maxlgrp = Lgrowth.Nrow();
-
-//   double** lGrowth = ToMatrix(Lgrowth, maxlgrp, aux);
-//   double** wGrowth = ToMatrix(Wgrowth, maxlgrp, aux);
-
-
-  for (i = 0; i < nrow; i++) {
-	int maxCol = v[i]->maxCol();
-	int minCol = v[i]->minCol();
-    //the part that grows to or above the highest length group
-    num = 0.0;
-    wt = 0.0;
-
-    for (lgrp = maxCol - 1; lgrp >= maxCol - maxlgrp; lgrp--) {
-      for (grow = maxCol - lgrp - 1; grow < maxlgrp; grow++) {
-        tmp = Lgrowth[grow][lgrp] * (*v[i])[lgrp].N;
-        num += tmp;
-        wt += tmp * (Wgrowth[grow][lgrp] + (*v[i])[lgrp].W);
-      }
-    }
-
-    lgrp = maxCol - 1;
-    if (isZero(num) || (wt < verysmall)) {
-      (*v[i])[lgrp].setToZero();
-    } else {
-      (*v[i])[lgrp].W = wt / num;
-      (*v[i])[lgrp].N = num;
-    }
-
-
-    //the central diagonal part of the length division
-    for (lgrp = maxCol - 2; lgrp >= minCol + maxlgrp - 1; lgrp--) {
-      num = 0.0;
-      wt = 0.0;
-      for (grow = 0; grow < maxlgrp; grow++) {
-        tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
-        num += tmp;
-        wt += tmp * (Wgrowth[grow][lgrp - grow] + (*v[i])[lgrp - grow].W);
-      }
-
-      if (isZero(num) || (wt < verysmall)) {
-        (*v[i])[lgrp].setToZero();
-      } else {
-        (*v[i])[lgrp].W = wt / num;
-        (*v[i])[lgrp].N = num;
-      }
-    }
-
-    //the lowest part of the length division
-    for (lgrp = minCol + maxlgrp - 2; lgrp >= minCol; lgrp--) {
-      num = 0.0;
-      wt = 0.0;
-      for (grow = 0; grow <= lgrp - minCol; grow++) {
-        tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
-        num += tmp;
-        wt += tmp * (Wgrowth[grow][lgrp - grow] + (*v[i])[lgrp - grow].W);
-      }
-
-      if (isZero(num) || (wt < verysmall)) {
-        (*v[i])[lgrp].setToZero();
-      } else {
-        (*v[i])[lgrp].W = wt / num;
-        (*v[i])[lgrp].N = num;
-      }
-    }
-  }
+void AgeBandMatrix::Grow(const Matrix& Lgrowth, const Matrix& Wgrowth) {
+	int i, lgrp, grow, maxlgrp;
+	double num, wt, tmp;
+
+	maxlgrp = Lgrowth.Nrow();
+
+	for (i = 0; i < nrow; i++) {
+		int maxCol = v[i]->maxCol();
+		int minCol = v[i]->minCol();
+		//the part that grows to or above the highest length group
+		num = 0.0;
+		wt = 0.0;
+
+		for (lgrp = maxCol - 1; lgrp >= maxCol - maxlgrp; lgrp--) {
+			for (grow = maxCol - lgrp - 1; grow < maxlgrp; grow++) {
+				tmp = Lgrowth[grow][lgrp] * (*v[i])[lgrp].N;
+				num += tmp;
+				wt += tmp * (Wgrowth[grow][lgrp] + (*v[i])[lgrp].W);
+			}
+		}
+
+		lgrp = maxCol - 1;
+		if (isZero(num) || (wt < verysmall)) {
+			(*v[i])[lgrp].setToZero();
+		} else {
+			(*v[i])[lgrp].W = wt / num;
+			(*v[i])[lgrp].N = num;
+		}
+
+		//the central diagonal part of the length division
+		for (lgrp = maxCol - 2; lgrp >= minCol + maxlgrp - 1; lgrp--) {
+			num = 0.0;
+			wt = 0.0;
+			for (grow = 0; grow < maxlgrp; grow++) {
+				tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
+				num += tmp;
+				wt += tmp
+						* (Wgrowth[grow][lgrp - grow] + (*v[i])[lgrp - grow].W);
+			}
+			if (isZero(num) || (wt < verysmall)) {
+				(*v[i])[lgrp].setToZero();
+			} else {
+				(*v[i])[lgrp].W = wt / num;
+				(*v[i])[lgrp].N = num;
+			}
+		}
+
+		//the lowest part of the length division
+		for (lgrp = minCol + maxlgrp - 2; lgrp >= minCol; lgrp--) {
+			num = 0.0;
+			wt = 0.0;
+			for (grow = 0; grow <= lgrp - minCol; grow++) {
+				tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
+				num += tmp;
+				wt += tmp
+						* (Wgrowth[grow][lgrp - grow] + (*v[i])[lgrp - grow].W);
+			}
+			if (isZero(num) || (wt < verysmall)) {
+				(*v[i])[lgrp].setToZero();
+			} else {
+				(*v[i])[lgrp].W = wt / num;
+				(*v[i])[lgrp].N = num;
+			}
+		}
+	}
 }
 
-//Same program with certain num of fish made mature.
-void AgeBandMatrix::Grow(const DoubleMatrix& Lgrowth, const DoubleMatrix& Wgrowth, Maturity* const Mat, int area) {
+/********************************************************************************/
 
-  int i, lgrp, grow, maxlgrp, age;
-  double num, wt, matnum, tmp, ratio;
+///* JMB changed to deal with very small weights a bit better   */
+//void AgeBandMatrix::Grow(const DoubleMatrix& Lgrowth,
+//		const DoubleMatrix& Wgrowth) {
+//	int i, lgrp, grow, maxlgrp;
+//	double num, wt, tmp;
+//
+//	maxlgrp = Lgrowth.Nrow();
+//
+//	for (i = 0; i < nrow; i++) {
+//		int maxCol = v[i]->maxCol();
+//		int minCol = v[i]->minCol();
+//		//the part that grows to or above the highest length group
+//		num = 0.0;
+//		wt = 0.0;
+//
+//		for (lgrp = maxCol - 1; lgrp >= maxCol - maxlgrp; lgrp--) {
+//			for (grow = maxCol - lgrp - 1; grow < maxlgrp; grow++) {
+//				tmp = Lgrowth[grow][lgrp] * (*v[i])[lgrp].N;
+//				num += tmp;
+//				wt += tmp * (Wgrowth[grow][lgrp] + (*v[i])[lgrp].W);
+//			}
+//		}
+//
+//		lgrp = maxCol - 1;
+//		if (isZero(num) || (wt < verysmall)) {
+//			(*v[i])[lgrp].setToZero();
+//		} else {
+//			(*v[i])[lgrp].W = wt / num;
+//			(*v[i])[lgrp].N = num;
+//		}
+//
+//		//the central diagonal part of the length division
+//		for (lgrp = maxCol - 2; lgrp >= minCol + maxlgrp - 1; lgrp--) {
+//			num = 0.0;
+//			wt = 0.0;
+//			for (grow = 0; grow < maxlgrp; grow++) {
+//				tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
+//				num += tmp;
+//				wt += tmp
+//						* (Wgrowth[grow][lgrp - grow] + (*v[i])[lgrp - grow].W);
+//			}
+//
+//			if (isZero(num) || (wt < verysmall)) {
+//				(*v[i])[lgrp].setToZero();
+//			} else {
+//				(*v[i])[lgrp].W = wt / num;
+//				(*v[i])[lgrp].N = num;
+//			}
+//		}
+//
+//		//the lowest part of the length division
+//		for (lgrp = minCol + maxlgrp - 2; lgrp >= minCol; lgrp--) {
+//			num = 0.0;
+//			wt = 0.0;
+//			for (grow = 0; grow <= lgrp - minCol; grow++) {
+//				tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
+//				num += tmp;
+//				wt += tmp
+//						* (Wgrowth[grow][lgrp - grow] + (*v[i])[lgrp - grow].W);
+//			}
+//
+//			if (isZero(num) || (wt < verysmall)) {
+//				(*v[i])[lgrp].setToZero();
+//			} else {
+//				(*v[i])[lgrp].W = wt / num;
+//				(*v[i])[lgrp].N = num;
+//			}
+//		}
+//	}
+//}
+//Same program with certain num of fish made mature.
+void AgeBandMatrix::Grow(const Matrix& Lgrowth, const Matrix& Wgrowth,
+		Maturity* const Mat, int area) {
 
+	int i, lgrp, grow, maxlgrp, age;
+	double num, wt, matnum, tmp, ratio;
 
-  maxlgrp = Lgrowth.Nrow();
-  for (i = 0; i < nrow; i++) {
-	  int maxCol = v[i]->maxCol();
-	    int minCol = v[i]->minCol();
-    age = i + minage;
-    num = 0.0;
-    wt = 0.0;
-    matnum = 0.0;
-    for (lgrp = maxCol - 1; lgrp >= maxCol - maxlgrp; lgrp--) {
-      for (grow = maxCol - lgrp - 1; grow < maxlgrp; grow++) {
-        ratio = Mat->calcMaturation(age, lgrp, grow, (*v[i])[lgrp].W);
-        tmp = Lgrowth[grow][lgrp] * (*v[i])[lgrp].N;
-        matnum += (tmp * ratio);
-        num += tmp;
-        wt += tmp * (Wgrowth[grow][lgrp] + (*v[i])[lgrp].W);
-      }
-    }
-
-    lgrp = maxCol - 1;
-    if (isZero(num) || (wt < verysmall)) {
-      //no fish grow to this length cell
-      (*v[i])[lgrp].setToZero();
-      Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
-    } else if (isZero(matnum)) {
-      //none of the fish that grow to this length cell mature
-      (*v[i])[lgrp].W = wt / num;
-      (*v[i])[lgrp].N = num;
-      Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
-    } else if (isEqual(num, matnum) || (matnum > num)) {
-      //all the fish that grow to this length cell mature
-      (*v[i])[lgrp].setToZero();
-      Mat->storeMatureStock(area, age, lgrp, num, wt / num);
-    } else {
-      (*v[i])[lgrp].W = wt / num;
-      (*v[i])[lgrp].N = num - matnum;
-      Mat->storeMatureStock(area, age, lgrp, matnum, wt / num);
-    }
-
-
-    for (lgrp = maxCol - 2; lgrp >= minCol + maxlgrp - 1; lgrp--) {
-      num = 0.0;
-      wt = 0.0;
-      matnum = 0.0;
-      for (grow = 0; grow < maxlgrp; grow++) {
-        ratio = Mat->calcMaturation(age, lgrp, grow, (*v[i])[lgrp - grow].W);
-        tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
-        matnum += (tmp * ratio);
-        num += tmp;
-        wt += tmp * (Wgrowth[grow][lgrp - grow] + (*v[i])[lgrp - grow].W);
-      }
-
-      if (isZero(num) || (wt < verysmall)) {
-        //no fish grow to this length cell
-        (*v[i])[lgrp].setToZero();
-        Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
-      } else if (isZero(matnum)) {
-        //none of the fish that grow to this length cell mature
-        (*v[i])[lgrp].W = wt / num;
-        (*v[i])[lgrp].N = num;
-        Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
-      } else if (isEqual(num, matnum) || (matnum > num)) {
-        //all the fish that grow to this length cell mature
-        (*v[i])[lgrp].setToZero();
-        Mat->storeMatureStock(area, age, lgrp, num, wt / num);
-      } else {
-        (*v[i])[lgrp].W = wt / num;
-        (*v[i])[lgrp].N = num - matnum;
-        Mat->storeMatureStock(area, age, lgrp, matnum, wt / num);
-      }
-    }
-
-    for (lgrp = minCol + maxlgrp - 2; lgrp >= minCol; lgrp--) {
-      num = 0.0;
-      wt = 0.0;
-      matnum = 0.0;
-      for (grow = 0; grow <= lgrp - minCol; grow++) {
-        ratio = Mat->calcMaturation(age, lgrp, grow, (*v[i])[lgrp - grow].W);
-        tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
-        matnum += (tmp * ratio);
-        num += tmp;
-        wt += tmp * (Wgrowth[grow][lgrp - grow] + (*v[i])[lgrp - grow].W);
-      }
-
-      if (isZero(num) || (wt < verysmall)) {
-        //no fish grow to this length cell
-        (*v[i])[lgrp].setToZero();
-        Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
-      } else if (isZero(matnum)) {
-        //none of the fish that grow to this length cell mature
-        (*v[i])[lgrp].W = wt / num;
-        (*v[i])[lgrp].N = num;
-        Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
-      } else if (isEqual(num, matnum) || (matnum > num)) {
-        //all the fish that grow to this length cell mature
-        (*v[i])[lgrp].setToZero();
-        Mat->storeMatureStock(area, age, lgrp, num, wt / num);
-      } else {
-        (*v[i])[lgrp].W = wt / num;
-        (*v[i])[lgrp].N = num - matnum;
-        Mat->storeMatureStock(area, age, lgrp, matnum, wt / num);
-      }
-    }
-  }
+	maxlgrp = Lgrowth.Nrow();
+	for (i = 0; i < nrow; i++) {
+		int maxCol = v[i]->maxCol();
+		int minCol = v[i]->minCol();
+		age = i + minage;
+		num = 0.0;
+		wt = 0.0;
+		matnum = 0.0;
+		for (lgrp = maxCol - 1; lgrp >= maxCol - maxlgrp; lgrp--) {
+			for (grow = maxCol - lgrp - 1; grow < maxlgrp; grow++) {
+				ratio = Mat->calcMaturation(age, lgrp, grow, (*v[i])[lgrp].W);
+				tmp = Lgrowth[grow][lgrp] * (*v[i])[lgrp].N;
+				matnum += (tmp * ratio);
+				num += tmp;
+				wt += tmp * (Wgrowth[grow][lgrp] + (*v[i])[lgrp].W);
+			}
+		}
+
+		lgrp = maxCol - 1;
+		if (isZero(num) || (wt < verysmall)) {
+			//no fish grow to this length cell
+			(*v[i])[lgrp].setToZero();
+			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
+		} else if (isZero(matnum)) {
+			//none of the fish that grow to this length cell mature
+			(*v[i])[lgrp].W = wt / num;
+			(*v[i])[lgrp].N = num;
+			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
+		} else if (isEqual(num, matnum) || (matnum > num)) {
+			//all the fish that grow to this length cell mature
+			(*v[i])[lgrp].setToZero();
+			Mat->storeMatureStock(area, age, lgrp, num, wt / num);
+		} else {
+			(*v[i])[lgrp].W = wt / num;
+			(*v[i])[lgrp].N = num - matnum;
+			Mat->storeMatureStock(area, age, lgrp, matnum, wt / num);
+		}
+
+		for (lgrp = maxCol - 2; lgrp >= minCol + maxlgrp - 1; lgrp--) {
+			num = 0.0;
+			wt = 0.0;
+			matnum = 0.0;
+			for (grow = 0; grow < maxlgrp; grow++) {
+				ratio = Mat->calcMaturation(age, lgrp, grow,
+						(*v[i])[lgrp - grow].W);
+				tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
+				matnum += (tmp * ratio);
+				num += tmp;
+				wt += tmp
+						* (Wgrowth[grow][lgrp - grow] + (*v[i])[lgrp - grow].W);
+			}
+
+			if (isZero(num) || (wt < verysmall)) {
+				//no fish grow to this length cell
+				(*v[i])[lgrp].setToZero();
+				Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
+			} else if (isZero(matnum)) {
+				//none of the fish that grow to this length cell mature
+				(*v[i])[lgrp].W = wt / num;
+				(*v[i])[lgrp].N = num;
+				Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
+			} else if (isEqual(num, matnum) || (matnum > num)) {
+				//all the fish that grow to this length cell mature
+				(*v[i])[lgrp].setToZero();
+				Mat->storeMatureStock(area, age, lgrp, num, wt / num);
+			} else {
+				(*v[i])[lgrp].W = wt / num;
+				(*v[i])[lgrp].N = num - matnum;
+				Mat->storeMatureStock(area, age, lgrp, matnum, wt / num);
+			}
+		}
+
+		for (lgrp = minCol + maxlgrp - 2; lgrp >= minCol; lgrp--) {
+			num = 0.0;
+			wt = 0.0;
+			matnum = 0.0;
+			for (grow = 0; grow <= lgrp - minCol; grow++) {
+				ratio = Mat->calcMaturation(age, lgrp, grow,
+						(*v[i])[lgrp - grow].W);
+				tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
+				matnum += (tmp * ratio);
+				num += tmp;
+				wt += tmp
+						* (Wgrowth[grow][lgrp - grow] + (*v[i])[lgrp - grow].W);
+			}
+
+			if (isZero(num) || (wt < verysmall)) {
+				//no fish grow to this length cell
+				(*v[i])[lgrp].setToZero();
+				Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
+			} else if (isZero(matnum)) {
+				//none of the fish that grow to this length cell mature
+				(*v[i])[lgrp].W = wt / num;
+				(*v[i])[lgrp].N = num;
+				Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
+			} else if (isEqual(num, matnum) || (matnum > num)) {
+				//all the fish that grow to this length cell mature
+				(*v[i])[lgrp].setToZero();
+				Mat->storeMatureStock(area, age, lgrp, num, wt / num);
+			} else {
+				(*v[i])[lgrp].W = wt / num;
+				(*v[i])[lgrp].N = num - matnum;
+				Mat->storeMatureStock(area, age, lgrp, matnum, wt / num);
+			}
+		}
+	}
 }
 
 //fleksibest formulation - weight read in from file (should be positive)
-void AgeBandMatrix::Grow(const DoubleMatrix& Lgrowth, const DoubleVector& Weight) {
-  int i, lgrp, grow, maxlgrp;
-  double num;
-
-  maxlgrp = Lgrowth.Nrow();
-
-  for (i = 0; i < nrow; i++) {
-	  int maxCol = v[i]->maxCol();
-	    int minCol = v[i]->minCol();
-    num = 0.0;
-    for (lgrp = maxCol - 1; lgrp >= maxCol - maxlgrp; lgrp--)
-      for (grow = maxCol - lgrp - 1; grow < maxlgrp; grow++)
-        num += (Lgrowth[grow][lgrp] * (*v[i])[lgrp].N);
-
-    lgrp = maxCol - 1;
-    if (isZero(num)) {
-      (*v[i])[lgrp].setToZero();
-    } else {
-      (*v[i])[lgrp].N = num;
-      (*v[i])[lgrp].W = Weight[lgrp];
-    }
-
-    for (lgrp = maxCol - 2; lgrp >= minCol + maxlgrp - 1; lgrp--) {
-      num = 0.0;
-      for (grow = 0; grow < maxlgrp; grow++)
-        num += (Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N);
-
-      if (isZero(num)) {
-        (*v[i])[lgrp].setToZero();
-      } else {
-        (*v[i])[lgrp].N = num;
-        (*v[i])[lgrp].W = Weight[lgrp];
-      }
-    }
-
-    for (lgrp = minCol + maxlgrp - 2; lgrp >= minCol; lgrp--) {
-      num = 0.0;
-      for (grow = 0; grow <= lgrp - minCol; grow++)
-        num += (Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N);
-
-      if (isZero(num)) {
-        (*v[i])[lgrp].setToZero();
-      } else {
-        (*v[i])[lgrp].N = num;
-        (*v[i])[lgrp].W = Weight[lgrp];
-      }
-    }
-  }
+void AgeBandMatrix::Grow(const Matrix& Lgrowth, const DoubleVector& Weight) {
+	int i, lgrp, grow, maxlgrp;
+	double num;
+
+	maxlgrp = Lgrowth.Nrow();
+
+	for (i = 0; i < nrow; i++) {
+		int maxCol = v[i]->maxCol();
+		int minCol = v[i]->minCol();
+		num = 0.0;
+		for (lgrp = maxCol - 1; lgrp >= maxCol - maxlgrp; lgrp--)
+			for (grow = maxCol - lgrp - 1; grow < maxlgrp; grow++)
+				num += (Lgrowth[grow][lgrp] * (*v[i])[lgrp].N);
+
+		lgrp = maxCol - 1;
+		if (isZero(num)) {
+			(*v[i])[lgrp].setToZero();
+		} else {
+			(*v[i])[lgrp].N = num;
+			(*v[i])[lgrp].W = Weight[lgrp];
+		}
+
+		for (lgrp = maxCol - 2; lgrp >= minCol + maxlgrp - 1; lgrp--) {
+			num = 0.0;
+			for (grow = 0; grow < maxlgrp; grow++)
+				num += (Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N);
+
+			if (isZero(num)) {
+				(*v[i])[lgrp].setToZero();
+			} else {
+				(*v[i])[lgrp].N = num;
+				(*v[i])[lgrp].W = Weight[lgrp];
+			}
+		}
+
+		for (lgrp = minCol + maxlgrp - 2; lgrp >= minCol; lgrp--) {
+			num = 0.0;
+			for (grow = 0; grow <= lgrp - minCol; grow++)
+				num += (Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N);
+
+			if (isZero(num)) {
+				(*v[i])[lgrp].setToZero();
+			} else {
+				(*v[i])[lgrp].N = num;
+				(*v[i])[lgrp].W = Weight[lgrp];
+			}
+		}
+	}
 }
 
 //fleksibest formulation - weight read in from file (should be positive)
 //Same program with certain num of fish made mature.
-void AgeBandMatrix::Grow(const DoubleMatrix& Lgrowth, const DoubleVector& Weight, Maturity* const Mat, int area) {
+void AgeBandMatrix::Grow(const Matrix& Lgrowth, const DoubleVector& Weight,
+		Maturity* const Mat, int area) {
 
-  int i, lgrp, grow, maxlgrp, age;
-  double num, matnum, tmp, ratio;
+	int i, lgrp, grow, maxlgrp, age;
+	double num, matnum, tmp, ratio;
 
-  maxlgrp = Lgrowth.Nrow();
+	maxlgrp = Lgrowth.Nrow();
 
-  for (i = 0; i < nrow; i++) {
-	  int maxCol = v[i]->maxCol();
-	    int minCol = v[i]->minCol();
-    age = i + minage;
-    num = 0.0;
-    matnum = 0.0;
-    for (lgrp = maxCol - 1; lgrp >= maxCol - maxlgrp; lgrp--) {
-      for (grow = maxCol - lgrp - 1; grow < maxlgrp; grow++) {
-        ratio = Mat->calcMaturation(age, lgrp, grow, (*v[i])[lgrp].W);
-        tmp = Lgrowth[grow][lgrp] * (*v[i])[lgrp].N;
-        matnum += (tmp * ratio);
-        num += tmp;
-      }
-    }
-
-    lgrp = maxCol - 1;
-    if (isZero(num)) {
-      //no fish grow to this length cell
-      (*v[i])[lgrp].setToZero();
-      Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
-    } else if (isZero(matnum)) {
-      //none of the fish that grow to this length cell mature
-      (*v[i])[lgrp].W = Weight[lgrp];
-      (*v[i])[lgrp].N = num;
-      Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
-    } else if (isEqual(num, matnum) || (matnum > num)) {
-      //all the fish that grow to this length cell mature
-      (*v[i])[lgrp].setToZero();
-      Mat->storeMatureStock(area, age, lgrp, num, Weight[lgrp]);
-    } else {
-      (*v[i])[lgrp].W = Weight[lgrp];
-      (*v[i])[lgrp].N = num - matnum;
-      Mat->storeMatureStock(area, age, lgrp, matnum, Weight[lgrp]);
-    }
-
-    for (lgrp = maxCol - 2; lgrp >= minCol + maxlgrp - 1; lgrp--) {
-      num = 0.0;
-      matnum = 0.0;
-      for (grow = 0; grow < maxlgrp; grow++) {
-        ratio = Mat->calcMaturation(age, lgrp, grow, (*v[i])[lgrp - grow].W);
-        tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
-        matnum += (tmp * ratio);
-        num += tmp;
-      }
-
-      if (isZero(num)) {
-        //no fish grow to this length cell
-        (*v[i])[lgrp].setToZero();
-        Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
-      } else if (isZero(matnum)) {
-        //none of the fish that grow to this length cell mature
-        (*v[i])[lgrp].W = Weight[lgrp];
-        (*v[i])[lgrp].N = num;
-        Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
-      } else if (isEqual(num, matnum) || (matnum > num)) {
-        //all the fish that grow to this length cell mature
-        (*v[i])[lgrp].setToZero();
-        Mat->storeMatureStock(area, age, lgrp, num, Weight[lgrp]);
-      } else {
-        (*v[i])[lgrp].W = Weight[lgrp];
-        (*v[i])[lgrp].N = num - matnum;
-        Mat->storeMatureStock(area, age, lgrp, matnum, Weight[lgrp]);
-      }
-    }
-
-    for (lgrp = minCol + maxlgrp - 2; lgrp >= minCol; lgrp--) {
-      num = 0.0;
-      matnum = 0.0;
-      for (grow = 0; grow <= lgrp - minCol; grow++) {
-        ratio = Mat->calcMaturation(age, lgrp, grow, (*v[i])[lgrp - grow].W);
-        tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
-        matnum += (tmp * ratio);
-        num += tmp;
-      }
-
-      if (isZero(num)) {
-        //no fish grow to this length cell
-        (*v[i])[lgrp].setToZero();
-        Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
-      } else if (isZero(matnum)) {
-        //none of the fish that grow to this length cell mature
-        (*v[i])[lgrp].W = Weight[lgrp];
-        (*v[i])[lgrp].N = num;
-        Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
-      } else if (isEqual(num, matnum) || (matnum > num)) {
-        //all the fish that grow to this length cell mature
-        (*v[i])[lgrp].setToZero();
-        Mat->storeMatureStock(area, age, lgrp, num, Weight[lgrp]);
-      } else {
-        (*v[i])[lgrp].W = Weight[lgrp];
-        (*v[i])[lgrp].N = num - matnum;
-        Mat->storeMatureStock(area, age, lgrp, matnum, Weight[lgrp]);
-      }
-    }
-  }
+	for (i = 0; i < nrow; i++) {
+		int maxCol = v[i]->maxCol();
+		int minCol = v[i]->minCol();
+		age = i + minage;
+		num = 0.0;
+		matnum = 0.0;
+		for (lgrp = maxCol - 1; lgrp >= maxCol - maxlgrp; lgrp--) {
+			for (grow = maxCol - lgrp - 1; grow < maxlgrp; grow++) {
+				ratio = Mat->calcMaturation(age, lgrp, grow, (*v[i])[lgrp].W);
+				tmp = Lgrowth[grow][lgrp] * (*v[i])[lgrp].N;
+				matnum += (tmp * ratio);
+				num += tmp;
+			}
+		}
+
+		lgrp = maxCol - 1;
+		if (isZero(num)) {
+			//no fish grow to this length cell
+			(*v[i])[lgrp].setToZero();
+			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
+		} else if (isZero(matnum)) {
+			//none of the fish that grow to this length cell mature
+			(*v[i])[lgrp].W = Weight[lgrp];
+			(*v[i])[lgrp].N = num;
+			Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
+		} else if (isEqual(num, matnum) || (matnum > num)) {
+			//all the fish that grow to this length cell mature
+			(*v[i])[lgrp].setToZero();
+			Mat->storeMatureStock(area, age, lgrp, num, Weight[lgrp]);
+		} else {
+			(*v[i])[lgrp].W = Weight[lgrp];
+			(*v[i])[lgrp].N = num - matnum;
+			Mat->storeMatureStock(area, age, lgrp, matnum, Weight[lgrp]);
+		}
+
+		for (lgrp = maxCol - 2; lgrp >= minCol + maxlgrp - 1; lgrp--) {
+			num = 0.0;
+			matnum = 0.0;
+			for (grow = 0; grow < maxlgrp; grow++) {
+				ratio = Mat->calcMaturation(age, lgrp, grow,
+						(*v[i])[lgrp - grow].W);
+				tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
+				matnum += (tmp * ratio);
+				num += tmp;
+			}
+
+			if (isZero(num)) {
+				//no fish grow to this length cell
+				(*v[i])[lgrp].setToZero();
+				Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
+			} else if (isZero(matnum)) {
+				//none of the fish that grow to this length cell mature
+				(*v[i])[lgrp].W = Weight[lgrp];
+				(*v[i])[lgrp].N = num;
+				Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
+			} else if (isEqual(num, matnum) || (matnum > num)) {
+				//all the fish that grow to this length cell mature
+				(*v[i])[lgrp].setToZero();
+				Mat->storeMatureStock(area, age, lgrp, num, Weight[lgrp]);
+			} else {
+				(*v[i])[lgrp].W = Weight[lgrp];
+				(*v[i])[lgrp].N = num - matnum;
+				Mat->storeMatureStock(area, age, lgrp, matnum, Weight[lgrp]);
+			}
+		}
+
+		for (lgrp = minCol + maxlgrp - 2; lgrp >= minCol; lgrp--) {
+			num = 0.0;
+			matnum = 0.0;
+			for (grow = 0; grow <= lgrp - minCol; grow++) {
+				ratio = Mat->calcMaturation(age, lgrp, grow,
+						(*v[i])[lgrp - grow].W);
+				tmp = Lgrowth[grow][lgrp - grow] * (*v[i])[lgrp - grow].N;
+				matnum += (tmp * ratio);
+				num += tmp;
+			}
+
+			if (isZero(num)) {
+				//no fish grow to this length cell
+				(*v[i])[lgrp].setToZero();
+				Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
+			} else if (isZero(matnum)) {
+				//none of the fish that grow to this length cell mature
+				(*v[i])[lgrp].W = Weight[lgrp];
+				(*v[i])[lgrp].N = num;
+				Mat->storeMatureStock(area, age, lgrp, 0.0, 0.0);
+			} else if (isEqual(num, matnum) || (matnum > num)) {
+				//all the fish that grow to this length cell mature
+				(*v[i])[lgrp].setToZero();
+				Mat->storeMatureStock(area, age, lgrp, num, Weight[lgrp]);
+			} else {
+				(*v[i])[lgrp].W = Weight[lgrp];
+				(*v[i])[lgrp].N = num - matnum;
+				Mat->storeMatureStock(area, age, lgrp, matnum, Weight[lgrp]);
+			}
+		}
+	}
 }