GRASS Programmer's Manual  6.4.3(2013)-r
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Macros Pages
N_gradient.c
Go to the documentation of this file.
1 
2 /*****************************************************************************
3 *
4 * MODULE: Grass PDE Numerical Library
5 * AUTHOR(S): Soeren Gebbert, Berlin (GER) Dec 2006
6 * soerengebbert <at> gmx <dot> de
7 *
8 * PURPOSE: gradient management functions
9 * part of the gpde library
10 *
11 * COPYRIGHT: (C) 2000 by the GRASS Development Team
12 *
13 * This program is free software under the GNU General Public
14 * License (>=v2). Read the file COPYING that comes with GRASS
15 * for details.
16 *
17 *****************************************************************************/
18 
19 #include <grass/N_pde.h>
20 
28 {
29  N_gradient_2d *grad;
30 
31  grad = (N_gradient_2d *) G_calloc(1, sizeof(N_gradient_2d));
32 
33  return grad;
34 }
35 
43 {
44  G_free(grad);
45  grad = NULL;
46 
47  return;
48 }
49 
60 N_gradient_2d *N_create_gradient_2d(double NC, double SC, double WC,
61  double EC)
62 {
63  N_gradient_2d *grad;
64 
65  G_debug(5, "N_create_gradient_2d: create N_gradient_2d");
66 
67  grad = N_alloc_gradient_2d();
68 
69  grad->NC = NC;
70  grad->SC = SC;
71  grad->WC = WC;
72  grad->EC = EC;
73 
74  return grad;
75 }
76 
86 {
87  G_debug(5, "N_copy_gradient_2d: copy N_gradient_2d");
88 
89  if (!source || !target)
90  return 0;
91 
92  target->NC = source->NC;
93  target->SC = source->SC;
94  target->WC = source->WC;
95  target->EC = source->EC;
96 
97  return 1;
98 }
99 
116  N_gradient_2d * gradient, int col, int row)
117 {
118  double NC = 0, SC = 0, WC = 0, EC = 0;
119  N_gradient_2d *grad = gradient;
120 
121 
122  NC = N_get_array_2d_d_value(field->y_array, col, row);
123  SC = N_get_array_2d_d_value(field->y_array, col, row + 1);
124  WC = N_get_array_2d_d_value(field->x_array, col, row);
125  EC = N_get_array_2d_d_value(field->x_array, col + 1, row);
126 
127  G_debug(5,
128  "N_get_gradient_2d: calculate N_gradient_2d NC %g SC %g WC %g EC %g",
129  NC, SC, WC, EC);
130 
131  /*if gradient is a NULL pointer, create a new one */
132  if (!grad) {
133  grad = N_create_gradient_2d(NC, SC, WC, EC);
134  }
135  else {
136  grad->NC = NC;
137  grad->SC = SC;
138  grad->WC = WC;
139  grad->EC = EC;
140  }
141 
142  return grad;
143 }
144 
152 {
153  N_gradient_3d *grad;
154 
155  grad = (N_gradient_3d *) G_calloc(1, sizeof(N_gradient_3d));
156 
157  return grad;
158 }
159 
167 {
168  G_free(grad);
169  grad = NULL;
170 
171  return;
172 }
173 
174 
187 N_gradient_3d *N_create_gradient_3d(double NC, double SC, double WC,
188  double EC, double TC, double BC)
189 {
190  N_gradient_3d *grad;
191 
192  G_debug(5, "N_create_gradient_3d: create N_gradient_3d");
193 
194  grad = N_alloc_gradient_3d();
195 
196  grad->NC = NC;
197  grad->SC = SC;
198  grad->WC = WC;
199  grad->EC = EC;
200  grad->TC = TC;
201  grad->BC = BC;
202 
203  return grad;
204 }
205 
215 {
216  G_debug(5, "N_copy_gradient_3d: copy N_gradient_3d");
217 
218  if (!source || !target)
219  return 0;
220 
221  target->NC = source->NC;
222  target->SC = source->SC;
223  target->WC = source->WC;
224  target->EC = source->EC;
225  target->TC = source->TC;
226  target->BC = source->BC;
227 
228  return 1;
229 }
230 
231 
249  N_gradient_3d * gradient, int col, int row,
250  int depth)
251 {
252  double NC, SC, WC, EC, TC, BC;
253  N_gradient_3d *grad = gradient;
254 
255  NC = N_get_array_3d_d_value(field->y_array, col, row, depth);
256  SC = N_get_array_3d_d_value(field->y_array, col, row + 1, depth);
257  WC = N_get_array_3d_d_value(field->x_array, col, row, depth);
258  EC = N_get_array_3d_d_value(field->x_array, col + 1, row, depth);
259  BC = N_get_array_3d_d_value(field->z_array, col, row, depth);
260  TC = N_get_array_3d_d_value(field->z_array, col, row, depth + 1);
261 
262  G_debug(6,
263  "N_get_gradient_3d: calculate N_gradient_3d NC %g SC %g WC %g EC %g TC %g BC %g",
264  NC, SC, WC, EC, TC, BC);
265 
266  /*if gradient is a NULL pointer, create a new one */
267  if (!grad) {
268  grad = N_create_gradient_3d(NC, SC, WC, EC, TC, BC);
269  }
270  else {
271  grad->NC = NC;
272  grad->SC = SC;
273  grad->WC = WC;
274  grad->EC = EC;
275  grad->BC = BC;
276  grad->TC = TC;
277  }
278 
279  return grad;
280 }
281 
291 {
293 
294  grad =
295  (N_gradient_neighbours_x *) G_calloc(1,
296  sizeof(N_gradient_neighbours_x));
297 
298  return grad;
299 }
300 
308 {
309  G_free(grad);
310  grad = NULL;
311 
312  return;
313 }
314 
315 
330  double NEN, double WC,
331  double EC, double SWS,
332  double SES)
333 {
335 
336  G_debug(6,
337  "N_create_gradient_neighbours_x: create N_gradient_neighbours_x");
338 
340 
341  grad->NWN = NWN;
342  grad->NEN = NEN;
343  grad->WC = WC;
344  grad->EC = EC;
345  grad->SWS = SWS;
346  grad->SES = SES;
347 
348  return grad;
349 }
350 
359 int
361  N_gradient_neighbours_x * target)
362 {
363  G_debug(6, "N_copy_gradient_neighbours_x: copy N_gradient_neighbours_x");
364 
365  if (!source || !target)
366  return 0;
367 
368  target->NWN = source->NWN;
369  target->NEN = source->NEN;
370  target->WC = source->WC;
371  target->EC = source->EC;
372  target->SWS = source->SWS;
373  target->SES = source->SES;
374 
375  return 1;
376 }
377 
387 {
389 
390  grad =
391  (N_gradient_neighbours_y *) G_calloc(1,
392  sizeof(N_gradient_neighbours_y));
393 
394  return grad;
395 }
396 
404 {
405  G_free(grad);
406  grad = NULL;
407 
408  return;
409 }
410 
425  double NEE, double NC,
426  double SC, double SWW,
427  double SEE)
428 {
430 
431  G_debug(6,
432  "N_create_gradient_neighbours_y: create N_gradient_neighbours_y");
433 
435 
436  grad->NWW = NWW;
437  grad->NEE = NEE;
438  grad->NC = NC;
439  grad->SC = SC;
440  grad->SWW = SWW;
441  grad->SEE = SEE;
442 
443  return grad;
444 }
445 
454 int
456  N_gradient_neighbours_y * target)
457 {
458  G_debug(6, "N_copy_gradient_neighbours_y: copy N_gradient_neighbours_y");
459 
460  if (!source || !target)
461  return 0;
462 
463  target->NWW = source->NWW;
464  target->NEE = source->NEE;
465  target->NC = source->NC;
466  target->SC = source->SC;
467  target->SWW = source->SWW;
468  target->SEE = source->SEE;
469 
470  return 1;
471 }
472 
482 {
484 
485  grad =
486  (N_gradient_neighbours_z *) G_calloc(1,
487  sizeof(N_gradient_neighbours_z));
488 
489  return grad;
490 }
491 
499 {
500  G_free(grad);
501  grad = NULL;
502 
503  return;
504 }
505 
523  double NEZ, double WZ,
524  double CZ, double EZ,
525  double SWZ, double SZ,
526  double SEZ)
527 {
529 
530  G_debug(6,
531  "N_create_gradient_neighbours_z: create N_gradient_neighbours_z");
532 
534 
535  grad->NWZ = NWZ;
536  grad->NZ = NZ;
537  grad->NEZ = NEZ;
538  grad->WZ = WZ;
539  grad->CZ = CZ;
540  grad->EZ = EZ;
541  grad->SWZ = SWZ;
542  grad->SZ = SZ;
543  grad->SEZ = SEZ;
544 
545  return grad;
546 }
547 
556 int
558  N_gradient_neighbours_z * target)
559 {
560  G_debug(6, "N_copy_gradient_neighbours_z: copy N_gradient_neighbours_z");
561 
562  if (!source || !target)
563  return 0;
564 
565  target->NWZ = source->NWZ;
566  target->NZ = source->NZ;
567  target->NEZ = source->NEZ;
568  target->WZ = source->WZ;
569  target->CZ = source->CZ;
570  target->EZ = source->EZ;
571  target->SWZ = source->SWZ;
572  target->SZ = source->SZ;
573  target->SEZ = source->SEZ;
574 
575  return 1;
576 }
577 
588 {
590 
591  grad =
592  (N_gradient_neighbours_2d *) G_calloc(1,
593  sizeof
595 
598 
599  return grad;
600 }
601 
609 {
610 
613 
614  G_free(grad);
615  grad = NULL;
616 
617  return;
618 }
619 
632 {
634  int fail = 0;
635 
636  G_debug(5,
637  "N_create_gradient_neighbours_2d: create N_gradient_neighbours_2d");
638 
640 
641  if (!N_copy_gradient_neighbours_x(x, grad->x))
642  fail++;
643  if (!N_copy_gradient_neighbours_y(y, grad->y))
644  fail++;
645 
646  if (fail > 0) {
648  grad = NULL;
649  }
650 
651  return grad;
652 }
653 
662 int
664  N_gradient_neighbours_2d * target)
665 {
666  int fail = 0;
667 
668  G_debug(5,
669  "N_copy_gradient_neighbours_2d: copy N_gradient_neighbours_2d");
670 
671  if (!source || !target)
672  return 0;
673 
674  if (!(N_copy_gradient_neighbours_x(source->x, target->x)))
675  fail++;
676  if (!(N_copy_gradient_neighbours_y(source->y, target->y)))
677  fail++;
678 
679  if (fail > 0) {
680  return 0;
681  }
682 
683  return 1;
684 }
685 
703  field,
705  * gradient, int col,
706  int row)
707 {
708  double NWN, NEN, WC, EC, SWS, SES;
709  double NWW, NEE, NC, SC, SWW, SEE;
711  N_gradient_neighbours_x *grad_x = NULL;
712  N_gradient_neighbours_y *grad_y = NULL;
713 
714 
715  NWN = N_get_array_2d_d_value(field->x_array, col, row - 1);
716  NEN = N_get_array_2d_d_value(field->x_array, col + 1, row - 1);
717  WC = N_get_array_2d_d_value(field->x_array, col, row);
718  EC = N_get_array_2d_d_value(field->x_array, col + 1, row);
719  SWS = N_get_array_2d_d_value(field->x_array, col, row + 1);
720  SES = N_get_array_2d_d_value(field->x_array, col + 1, row + 1);
721 
722  NWW = N_get_array_2d_d_value(field->y_array, col - 1, row);
723  NEE = N_get_array_2d_d_value(field->y_array, col + 1, row);
724  NC = N_get_array_2d_d_value(field->y_array, col, row);
725  SC = N_get_array_2d_d_value(field->y_array, col, row + 1);
726  SWW = N_get_array_2d_d_value(field->y_array, col - 1, row + 1);
727  SEE = N_get_array_2d_d_value(field->y_array, col + 1, row + 1);
728 
729 
730  grad_x = N_create_gradient_neighbours_x(NWN, NEN, WC, EC, SWS, SES);
731  grad_y = N_create_gradient_neighbours_y(NWW, NEE, NC, SC, SWW, SEE);
732 
733  G_debug(5,
734  "N_get_gradient_neighbours_2d: calculate N_gradient_neighbours_x NWN %g NEN %g WC %g EC %g SWS %g SES %g",
735  NWN, NEN, WC, EC, SWS, SES);
736 
737  G_debug(5,
738  "N_get_gradient_neighbours_2d: calculate N_gradient_neighbours_y NWW %g NEE %g NC %g SC %g SWW %g SEE %g",
739  NWW, NEE, NC, SC, SWW, SEE);
740 
741 
742  /*if gradient is a NULL pointer, create a new one */
743  if (!gradient) {
744  grad = N_create_gradient_neighbours_2d(grad_x, grad_y);
745  gradient = grad;
746  }
747  else {
748  grad = N_create_gradient_neighbours_2d(grad_x, grad_y);
749  N_copy_gradient_neighbours_2d(grad, gradient);
751  }
752 
755 
756  return gradient;
757 }
758 
759 
770 {
772 
773  grad =
774  (N_gradient_neighbours_3d *) G_calloc(1,
775  sizeof
777 
786 
787  return grad;
788 }
789 
797 {
798 
807 
808  G_free(grad);
809  grad = NULL;
810 
811  return;
812 }
813 
833 {
835  int fail = 0;
836 
837  G_debug(5,
838  "N_create_gradient_neighbours_3d: create N_gradient_neighbours_3d");
839 
841 
842  if (!(N_copy_gradient_neighbours_x(xt, grad->xt)))
843  fail++;
844  if (!(N_copy_gradient_neighbours_x(xc, grad->xc)))
845  fail++;
846  if (!(N_copy_gradient_neighbours_x(xb, grad->xb)))
847  fail++;
848  if (!(N_copy_gradient_neighbours_y(yt, grad->yt)))
849  fail++;
850  if (!(N_copy_gradient_neighbours_y(yc, grad->yc)))
851  fail++;
852  if (!(N_copy_gradient_neighbours_y(yb, grad->yb)))
853  fail++;
854  if (!(N_copy_gradient_neighbours_z(zt, grad->zt)))
855  fail++;
856  if (!(N_copy_gradient_neighbours_z(zb, grad->zb)))
857  fail++;
858 
859  if (fail > 0) {
860  return NULL;
861  }
862 
863  return grad;
864 }
865 
874 int
876  N_gradient_neighbours_3d * target)
877 {
878  int fail = 0;
879 
880  G_debug(5,
881  "N_copy_gradient_neighbours_3d: copy N_gradient_neighbours_3d");
882 
883  if (!source || !target)
884  return 0;
885 
886  if (!(N_copy_gradient_neighbours_x(source->xt, target->xt)))
887  fail++;
888  if (!(N_copy_gradient_neighbours_x(source->xc, target->xc)))
889  fail++;
890  if (!(N_copy_gradient_neighbours_x(source->xb, target->xb)))
891  fail++;
892  if (!(N_copy_gradient_neighbours_y(source->yt, target->yt)))
893  fail++;
894  if (!(N_copy_gradient_neighbours_y(source->yc, target->yc)))
895  fail++;
896  if (!(N_copy_gradient_neighbours_y(source->yb, target->yb)))
897  fail++;
898  if (!(N_copy_gradient_neighbours_z(source->zt, target->zt)))
899  fail++;
900  if (!(N_copy_gradient_neighbours_z(source->zb, target->zb)))
901  fail++;
902 
903  if (fail > 0) {
904  return 0;
905  }
906 
907  return 1;
908 }
909 
921 {
922  N_gradient_field_2d *field;
923 
924  G_debug(5,
925  "N_alloc_gradient_field_2d: allocate a N_gradient_field_2d struct");
926 
927  field = (N_gradient_field_2d *) G_calloc(1, sizeof(N_gradient_field_2d));
928 
929  field->x_array = N_alloc_array_2d(cols, rows, 1, DCELL_TYPE);
930  field->y_array = N_alloc_array_2d(cols, rows, 1, DCELL_TYPE);
931 
932  field->cols = cols;
933  field->rows = rows;
934 
935  return field;
936 }
937 
945 {
946 
947  N_free_array_2d(field->x_array);
948  N_free_array_2d(field->y_array);
949 
950  G_free(field);
951 
952  field = NULL;
953 
954  return;
955 }
956 
965 int
967  N_gradient_field_2d * target)
968 {
969  G_debug(3, "N_copy_gradient_field_2d: copy N_gradient_field_2d");
970 
971  if (!source || !target)
972  return 0;
973 
974  N_copy_array_2d(source->x_array, target->x_array);
975  N_copy_array_2d(source->y_array, target->y_array);
976 
977  return 1;
978 }
979 
987 {
988  fprintf(stdout, "N_gradient_field_2d \n");
989  fprintf(stdout, "Cols %i\n", field->cols);
990  fprintf(stdout, "Rows: %i\n", field->rows);
991  fprintf(stdout, "X array pointer: %p\n", field->x_array);
992  fprintf(stdout, "Y array pointer: %p\n", field->y_array);
993  fprintf(stdout, "Min %g\n", field->min);
994  fprintf(stdout, "Max %g\n", field->max);
995  fprintf(stdout, "Sum %g\n", field->sum);
996  fprintf(stdout, "Mean %g\n", field->mean);
997  fprintf(stdout, "Nonull %i\n", field->nonull);
998  fprintf(stdout, "X array info \n");
1000  fprintf(stdout, "Y array info \n");
1002 
1003  return;
1004 }
1005 
1006 
1019 {
1020  N_gradient_field_3d *field;
1021 
1022  G_debug(5,
1023  "N_alloc_gradient_field_3d: allocate a N_gradient_field_3d struct");
1024 
1025  field = (N_gradient_field_3d *) G_calloc(1, sizeof(N_gradient_field_3d));
1026 
1027  field->x_array = N_alloc_array_3d(cols, rows, depths, 1, DCELL_TYPE);
1028  field->y_array = N_alloc_array_3d(cols, rows, depths, 1, DCELL_TYPE);
1029  field->z_array = N_alloc_array_3d(cols, rows, depths, 1, DCELL_TYPE);
1030 
1031  field->cols = cols;
1032  field->rows = rows;
1033  field->depths = depths;
1034 
1035  return field;
1036 }
1037 
1038 
1046 {
1047 
1048  N_free_array_3d(field->x_array);
1049  N_free_array_3d(field->y_array);
1050  N_free_array_3d(field->z_array);
1051 
1052  G_free(field);
1053 
1054  field = NULL;
1055 
1056  return;
1057 }
1058 
1059 
1068 int
1070  N_gradient_field_3d * target)
1071 {
1072  G_debug(3, "N_copy_gradient_field_3d: copy N_gradient_field_3d");
1073 
1074  if (!source || !target)
1075  return 0;
1076 
1077  N_copy_array_3d(source->x_array, target->x_array);
1078  N_copy_array_3d(source->y_array, target->y_array);
1079  N_copy_array_3d(source->z_array, target->z_array);
1080 
1081  return 1;
1082 }
1083 
1091 {
1092 
1093  fprintf(stdout, "N_gradient_field_3d \n");
1094  fprintf(stdout, "Cols %i\n", field->cols);
1095  fprintf(stdout, "Rows: %i\n", field->rows);
1096  fprintf(stdout, "Depths %i\n", field->depths);
1097  fprintf(stdout, "X array pointer: %p\n", field->x_array);
1098  fprintf(stdout, "Y array pointer: %p\n", field->y_array);
1099  fprintf(stdout, "Z array pointer: %p\n", field->z_array);
1100  fprintf(stdout, "Min %g\n", field->min);
1101  fprintf(stdout, "Max %g\n", field->max);
1102  fprintf(stdout, "Sum %g\n", field->sum);
1103  fprintf(stdout, "Mean %g\n", field->mean);
1104  fprintf(stdout, "Nonull %i\n", field->nonull);
1105  fprintf(stdout, "X array info \n");
1107  fprintf(stdout, "Y array info \n");
1109  fprintf(stdout, "Z array info \n");
1111 
1112  return;
1113 }
void N_free_array_2d(N_array_2d *data)
Release the memory of a N_array_2d structure.
Definition: N_arrays.c:127
N_gradient_neighbours_x * xt
Definition: N_pde.h:606
N_gradient_neighbours_z * zt
Definition: N_pde.h:614
N_gradient_neighbours_3d * N_alloc_gradient_neighbours_3d(void)
Allocate a N_gradient_neighbours_3d structure.
Definition: N_gradient.c:769
N_gradient_neighbours_z * N_create_gradient_neighbours_z(double NWZ, double NZ, double NEZ, double WZ, double CZ, double EZ, double SWZ, double SZ, double SEZ)
Allocate and initialize a N_gradient_neighbours_z structure.
Definition: N_gradient.c:522
void N_free_gradient_neighbours_z(N_gradient_neighbours_z *grad)
Free&#39;s a N_gradient_neighbours_z structure.
Definition: N_gradient.c:498
double EC
Definition: N_pde.h:520
void G_free(void *buf)
Free allocated memory.
Definition: gis/alloc.c:142
void N_free_gradient_2d(N_gradient_2d *grad)
Free&#39;s a N_gradient_2d structure.
Definition: N_gradient.c:42
Gradient between the cell neighbours in X and Y direction.
Definition: N_pde.h:593
void N_free_gradient_field_3d(N_gradient_field_3d *field)
Free&#39;s a N_gradient_neighbours_3d structure.
Definition: N_gradient.c:1045
Gradient between the cell neighbours in Z direction.
Definition: N_pde.h:585
void N_print_gradient_field_3d_info(N_gradient_field_3d *field)
Print gradient field information to stdout.
Definition: N_gradient.c:1090
void N_free_gradient_neighbours_x(N_gradient_neighbours_x *grad)
Free&#39;s a N_gradient_neighbours_x structure.
Definition: N_gradient.c:307
void N_free_array_3d(N_array_3d *data)
Release the memory of a N_array_3d.
Definition: N_arrays.c:777
Gradient between the cells in X and Y direction.
Definition: N_pde.h:509
N_gradient_neighbours_y * y
Definition: N_pde.h:597
int N_copy_gradient_3d(N_gradient_3d *source, N_gradient_3d *target)
copy a N_gradient_3d structure
Definition: N_gradient.c:214
int N_copy_gradient_neighbours_2d(N_gradient_neighbours_2d *source, N_gradient_neighbours_2d *target)
copy a N_gradient_neighbours_2d structure
Definition: N_gradient.c:663
N_array_2d * N_alloc_array_2d(int cols, int rows, int offset, int type)
Allocate memory for a N_array_2d data structure.
Definition: N_arrays.c:69
double WC
Definition: N_pde.h:520
int y
Definition: plot.c:34
int N_copy_gradient_neighbours_x(N_gradient_neighbours_x *source, N_gradient_neighbours_x *target)
copy a N_gradient_neighbours_x structure
Definition: N_gradient.c:360
N_gradient_3d * N_alloc_gradient_3d(void)
Allocate a N_gradient_3d structure.
Definition: N_gradient.c:151
int N_copy_gradient_2d(N_gradient_2d *source, N_gradient_2d *target)
copy a N_gradient_2d structure
Definition: N_gradient.c:85
N_array_3d * y_array
Definition: N_pde.h:637
N_gradient_2d * N_create_gradient_2d(double NC, double SC, double WC, double EC)
allocate and initialize a N_gradient_2d structure
Definition: N_gradient.c:60
void N_free_gradient_field_2d(N_gradient_field_2d *field)
Free&#39;s a N_gradient_neighbours_2d structure.
Definition: N_gradient.c:944
N_array_3d * N_alloc_array_3d(int cols, int rows, int depths, int offset, int type)
Allocate memory for a N_array_3d data structure.
Definition: N_arrays.c:723
N_gradient_neighbours_2d * N_create_gradient_neighbours_2d(N_gradient_neighbours_x *x, N_gradient_neighbours_y *y)
Allocate and initialize a N_gradient_neighbours_2d structure.
Definition: N_gradient.c:630
double SC
Definition: N_pde.h:520
N_gradient_neighbours_z * zb
Definition: N_pde.h:615
N_gradient_neighbours_2d * N_get_gradient_neighbours_2d(N_gradient_field_2d *field, N_gradient_neighbours_2d *gradient, int col, int row)
Return a N_gradient_neighbours_2d structure calculated from the input gradient field at position [row...
Definition: N_gradient.c:702
void N_print_array_2d_info(N_array_2d *data)
This function writes the data info of the array data to stdout.
Definition: N_arrays.c:608
N_gradient_3d * N_get_gradient_3d(N_gradient_field_3d *field, N_gradient_3d *gradient, int col, int row, int depth)
Return a N_gradient_3d structure calculated from the input gradient field at position [depth][row][co...
Definition: N_gradient.c:248
double NC
Definition: N_pde.h:520
N_array_2d * y_array
Definition: N_pde.h:625
N_gradient_field_2d * N_alloc_gradient_field_2d(int cols, int rows)
Allocate a N_gradient_field_2d.
Definition: N_gradient.c:920
N_gradient_neighbours_x * xb
Definition: N_pde.h:608
N_gradient_neighbours_y * yb
Definition: N_pde.h:612
void N_print_array_3d_info(N_array_3d *data)
Write the info of the array to stdout.
Definition: N_arrays.c:1194
double TC
Definition: N_pde.h:520
Gradient between the cell neighbours in X, Y and Z direction.
Definition: N_pde.h:603
N_array_3d * z_array
Definition: N_pde.h:638
Gradient between the cell neighbours in X direction.
Definition: N_pde.h:569
N_gradient_neighbours_y * yt
Definition: N_pde.h:610
double BC
Definition: N_pde.h:520
N_gradient_neighbours_x * N_create_gradient_neighbours_x(double NWN, double NEN, double WC, double EC, double SWS, double SES)
Allocate and initialize a N_gradient_neighbours_x structure.
Definition: N_gradient.c:329
N_gradient_neighbours_z * N_alloc_gradient_neighbours_z(void)
Allocate a N_gradient_neighbours_z structure.
Definition: N_gradient.c:481
double EC
Definition: N_pde.h:512
N_gradient_3d * N_create_gradient_3d(double NC, double SC, double WC, double EC, double TC, double BC)
allocate and initialize a N_gradient_3d structure
Definition: N_gradient.c:187
void N_print_gradient_field_2d_info(N_gradient_field_2d *field)
Print gradient field information to stdout.
Definition: N_gradient.c:986
void N_copy_array_2d(N_array_2d *source, N_array_2d *target)
Copy the source N_array_2d struct to the target N_array_2d struct.
Definition: N_arrays_calc.c:43
N_gradient_neighbours_2d * N_alloc_gradient_neighbours_2d(void)
Allocate a N_gradient_neighbours_2d structure.
Definition: N_gradient.c:587
N_gradient_neighbours_3d * N_create_gradient_neighbours_3d(N_gradient_neighbours_x *xt, N_gradient_neighbours_x *xc, N_gradient_neighbours_x *xb, N_gradient_neighbours_y *yt, N_gradient_neighbours_y *yc, N_gradient_neighbours_y *yb, N_gradient_neighbours_z *zt, N_gradient_neighbours_z *zb)
Allocate and initialize a N_gradient_neighbours_3d structure.
Definition: N_gradient.c:825
Gradient between the cells in X, Y and Z direction.
Definition: N_pde.h:517
void N_free_gradient_neighbours_2d(N_gradient_neighbours_2d *grad)
Free&#39;s a N_gradient_neighbours_2d structure.
Definition: N_gradient.c:608
N_gradient_neighbours_x * N_alloc_gradient_neighbours_x(void)
Allocate a N_gradient_neighbours_x structure.
Definition: N_gradient.c:290
double N_get_array_3d_d_value(N_array_3d *data, int col, int row, int depth)
This function returns the value of type float at position col, row, depth.
Definition: N_arrays.c:987
N_gradient_2d * N_get_gradient_2d(N_gradient_field_2d *field, N_gradient_2d *gradient, int col, int row)
Return a N_gradient_2d structure calculated from the input gradient field at position [row][col]...
Definition: N_gradient.c:115
return NULL
Definition: dbfopen.c:1394
tuple cols
int G_debug(int level, const char *msg,...)
Print debugging message.
Definition: gis/debug.c:51
int N_copy_gradient_neighbours_z(N_gradient_neighbours_z *source, N_gradient_neighbours_z *target)
copy a N_gradient_neighbours_z structure
Definition: N_gradient.c:557
N_array_3d * x_array
Definition: N_pde.h:636
N_gradient_field_3d * N_alloc_gradient_field_3d(int cols, int rows, int depths)
Allocate a N_gradient_field_3d.
Definition: N_gradient.c:1018
double WC
Definition: N_pde.h:512
DCELL N_get_array_2d_d_value(N_array_2d *data, int col, int row)
Returns the value of type DCELL at position col, row.
Definition: N_arrays.c:375
void N_free_gradient_3d(N_gradient_3d *grad)
Free&#39;s a N_gradient_3d structure.
Definition: N_gradient.c:166
N_gradient_neighbours_x * xc
Definition: N_pde.h:607
N_gradient_neighbours_y * N_create_gradient_neighbours_y(double NWW, double NEE, double NC, double SC, double SWW, double SEE)
Allocate and initialize a N_gradient_neighbours_y structure.
Definition: N_gradient.c:424
N_gradient_neighbours_y * yc
Definition: N_pde.h:611
int N_copy_gradient_neighbours_3d(N_gradient_neighbours_3d *source, N_gradient_neighbours_3d *target)
copy a N_gradient_neighbours_3d structure
Definition: N_gradient.c:875
void N_free_gradient_neighbours_3d(N_gradient_neighbours_3d *grad)
Free&#39;s a N_gradient_neighbours_3d structure.
Definition: N_gradient.c:796
N_gradient_2d * N_alloc_gradient_2d(void)
Allocate a N_gradient_2d structure.
Definition: N_gradient.c:27
Gradient between the cell neighbours in Y direction.
Definition: N_pde.h:577
N_gradient_neighbours_x * x
Definition: N_pde.h:596
double SC
Definition: N_pde.h:512
int N_copy_gradient_field_2d(N_gradient_field_2d *source, N_gradient_field_2d *target)
Copy N_gradient_field_2d structure from source to target.
Definition: N_gradient.c:966
double NC
Definition: N_pde.h:512
int N_copy_gradient_field_3d(N_gradient_field_3d *source, N_gradient_field_3d *target)
Copy N_gradient_field_3d structure from source to target.
Definition: N_gradient.c:1069
SC
Definition: wxgui.py:32
N_gradient_neighbours_y * N_alloc_gradient_neighbours_y(void)
Allocate a N_gradient_neighbours_y structure.
Definition: N_gradient.c:386
N_array_2d * x_array
Definition: N_pde.h:624
void N_copy_array_3d(N_array_3d *source, N_array_3d *target)
Copy the source N_array_3d struct to the target N_array_3d struct.
int N_copy_gradient_neighbours_y(N_gradient_neighbours_y *source, N_gradient_neighbours_y *target)
copy a N_gradient_neighbours_y structure
Definition: N_gradient.c:455
void N_free_gradient_neighbours_y(N_gradient_neighbours_y *grad)
Free&#39;s a N_gradient_neighbours_y structure.
Definition: N_gradient.c:403