Actual source code: ad_grad.h
petsc-3.3-p7 2013-05-11
1: /*
2: THIS PROGRAM DISCLOSES MATERIAL PROTECTABLE UNDER COPYRIGHT
3: LAWS OF THE UNITED STATES. FOR LICENSING INFORMATION CONTACT:
5: Paul Hovland and Boyana Norris, Mathematics and Computer Science Division,
6: Argonne National Laboratory, 9700 S. Cass Avenue, Argonne IL 60439,
7: {hovland,norris}@mcs.anl.gov.
8: */
10: #include "ad_grad_macro_axpys.h"
12: #if !defined(AD_GRAD_H)
13: #define AD_GRAD_H
15: #include <string.h>
17: PETSC_EXTERN int ad_grad_size;
18: PETSC_EXTERN int ad_total_grad_size; /*only used when generating MPI programs*/
19: PETSC_EXTERN int ad_grad_size_shadow;
21: # if defined(__cplusplus)
22: extern "C" {
23: # endif
24:
25: #define ad_AD_GradInitMPI(pargc, pargv) \
26: { \
27: ad_mpi_init(pargc, pargv, &ad_total_grad_size); \
28: }
31: #define ad_AD_GradFinalMPI() \
32: { \
33: ad_mpi_final(); \
34: }
36: #define ad_AD_GradFinal() \
37: { \
38: ad_grad_size = 0; \
39: }
43: #define ad_AD_GradInit(n) \
44: { \
45: if (n == -1) \
46: ad_grad_size = ad_GRAD_MAX; \
47: else \
48: ad_grad_size = n; \
49: ad_grad_size_shadow = 0; \
50: }
53: #define ad_AD_ClearGrad(gz) memset((char*)gz, 0, ad_GRAD_MAX*sizeof(double));
55: #define ad_AD_ClearGrad2(gz)\
56: {\
57: int iWiLlNeVeRCoNfLiCt0;\
58: for (iWiLlNeVeRCoNfLiCt0 = 0 ; iWiLlNeVeRCoNfLiCt0 < ad_GRAD_MAX; \
59: iWiLlNeVeRCoNfLiCt0++) {\
60: gz[iWiLlNeVeRCoNfLiCt0] = 0.0;\
61: }\
62: }
64: #define ad_AD_ClearGradArray(ggz,size)\
65: {\
66: int iWiLlNeVeRCoNfLiCt0;\
67: for (iWiLlNeVeRCoNfLiCt0 = 0 ; iWiLlNeVeRCoNfLiCt0 < size; \
68: iWiLlNeVeRCoNfLiCt0++) {\
69: ad_AD_ClearGrad(DERIV_grad((ggz)[iWiLlNeVeRCoNfLiCt0])); \
70: }\
71: }
73: #define ad_AD_CopyGrad(gz,gx) \
74: {\
75: int iWiLlNeVeRCoNfLiCt0;\
76: for (iWiLlNeVeRCoNfLiCt0 = 0 ; iWiLlNeVeRCoNfLiCt0 < ad_GRAD_MAX;\
77: iWiLlNeVeRCoNfLiCt0++) {\
78: gz[iWiLlNeVeRCoNfLiCt0] = gx[iWiLlNeVeRCoNfLiCt0];\
79: }\
80: }
82: # define ad_AD_GetTotalGradSize() ad_grad_size
83: # define ad_AD_SetTotalGradSize(x) ad_grad_size = x
85: # define ad_AD_IncrementTotalGradSize(x) \
86: { \
87: if (x + ad_grad_size_shadow > ad_GRAD_MAX) {\
88: SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_USER, "The number of independent variables exceeds the maximum compiled for!\n Edit your program and change Process adiC(%d) to Process adiC(%d)", x + ad_grad_size_shadow,ad_GRAD_MAX);\
89: }\
90: ad_grad_size_shadow += x;\
91: }
93: # define ad_AD_ExtractGrad(a, var) \
94: { \
95: int pOsItIoN; \
96: for (pOsItIoN = 0; pOsItIoN < ad_grad_size; pOsItIoN++) {\
97: (a)[pOsItIoN] = DERIV_grad(var)[pOsItIoN]; \
98: }\
99: }
100: # define ad_AD_ExtractVal(a, var) \
101: { \
102: a = DERIV_val(var); \
103: }
104: # define ad_AD_SetGrad(a, var) \
105: { \
106: int pOsItIoN; \
107: for (pOsItIoN = 0; pOsItIoN < ad_grad_size; pOsItIoN++) {\
108: DERIV_grad(var)[pOsItIoN] = (a)[pOsItIoN]; \
109: }\
110: }
112: # define ad_AD_SetIndepDone() ad_AD_CommitShadowVar()
113: # define ad_AD_ResetIndep() ad_AD_ResetShadowVar()
114: # define ad_AD_SetIndep(var) \
115: { \
116: int pOsItIoN = ad_AD_IncrShadowVar(); \
117: if (pOsItIoN > ad_GRAD_MAX) {\
118: SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_USER, "The number of independent variables exceeds the maximum compiled for!\n Edit your program and change Process adiC(%d) to Process adiC(%d)",pOsItIoN ,ad_GRAD_MAX);\
119: }\
120: ad_AD_ClearGrad(DERIV_grad(var)); \
121: DERIV_grad(var)[pOsItIoN] = 1; \
122: }
123: # define ad_AD_SetIndepArray(vars, size) \
124: { \
125: int iWiLlNeVeRCoNfLiCt; \
126: for (iWiLlNeVeRCoNfLiCt = 0; iWiLlNeVeRCoNfLiCt < size; \
127: iWiLlNeVeRCoNfLiCt++) { \
128: ad_AD_ClearGrad(DERIV_grad((vars)[iWiLlNeVeRCoNfLiCt])); \
129: DERIV_grad((vars)[iWiLlNeVeRCoNfLiCt])[ad_AD_IncrShadowVar()] = 1; \
130: } \
131: }
133: # define ad_AD_SetIndepArrayElement(var, index) \
134: { \
135: ad_AD_ClearGrad(DERIV_grad((var)[index])); \
136: DERIV_grad((var)[index])[ad_AD_IncrShadowVar()] = 1; \
137: }
139: # define ad_AD_SetIndepArrayColored(vars, size, colors) \
140: { \
141: int iWiLlNeVeRCoNfLiCt; \
142: for (iWiLlNeVeRCoNfLiCt = 0; iWiLlNeVeRCoNfLiCt < size; \
143: iWiLlNeVeRCoNfLiCt++) { \
144: ad_AD_ClearGrad2(DERIV_grad((vars)[iWiLlNeVeRCoNfLiCt])); \
145: DERIV_grad((vars)[iWiLlNeVeRCoNfLiCt])[ad_grad_size_shadow+(colors)[iWiLlNeVeRCoNfLiCt]] = 1; \
146: } \
147: }
149: /* values array is the same length as vars */
150: # define ad_AD_SetIndepVector(vars, size, values) \
151: { \
152: int iWiLlNeVeRCoNfLiCt; \
153: for (iWiLlNeVeRCoNfLiCt = 0; iWiLlNeVeRCoNfLiCt < size; \
154: iWiLlNeVeRCoNfLiCt++) { \
155: ad_AD_ClearGrad(DERIV_grad((vars)[iWiLlNeVeRCoNfLiCt])); \
156: DERIV_grad((vars)[iWiLlNeVeRCoNfLiCt])[ad_grad_size_shadow] = (values)[iWiLlNeVeRCoNfLiCt]; \
157: } \
158: }
160: #define ad_AD_SetValArray(vars, size, values) \
161: { \
162: int iWiLlNeVeRCoNfLiCt; \
163: for (iWiLlNeVeRCoNfLiCt = 0; iWiLlNeVeRCoNfLiCt < size; \
164: iWiLlNeVeRCoNfLiCt++) { \
165: DERIV_val((vars)[iWiLlNeVeRCoNfLiCt]) = (values)[iWiLlNeVeRCoNfLiCt]; \
166: } \
167: }
169: PETSC_EXTERN int ad_AD_IncrShadowVar(void);
170: PETSC_EXTERN void ad_AD_CommitShadowVar(void);
171: PETSC_EXTERN void ad_AD_ResetShadowVar(void);
174: # if defined(__cplusplus)
175: }
176: # endif
177: #endif /*AD_GRAD_H*/