ITM AMNS: User Interface  \$Id: Doxyfile 502 2015-10-15 12:23:45Z dpc $
amns_jni_call.c
Go to the documentation of this file.
1 #include "amns_interface.h"
2 #include <stdbool.h>
3 #include <math.h>
4 #include <assert.h>
5 #include <stdio.h>
6 #include "amns_jni_call.h"
7 #include <jni.h>
8 
9 void copyCError2JavaError( amns_c_error_type *error_stat, JNIEnv *env, jobject error_structure) {
10 
11  // we have to return values into Java
12  // note that we are playing here with pointers - they should be preserved accross calls
13  // but will not be garbage collected from java
14 
15  jclass cls = (*env)->GetObjectClass(env, error_structure);
16  jfieldID paramFlag = (*env)->GetFieldID(env, cls, "flag", "Z");
17  jfieldID paramString = (*env)->GetFieldID(env, cls, "string", "Ljava/lang/String;");
18 
19  jstring ret_message;
20 
21  if(error_stat->string != NULL) {
22  ret_message = (*env)->NewStringUTF(env,error_stat->string);
23  } else {
24  ret_message = (*env)->NewStringUTF(env,"");
25  }
26  if(ret_message == NULL) {
27  (*env)->SetObjectField(env, error_structure, paramString, "");
28  } else {
29  (*env)->SetObjectField(env, error_structure, paramString, ret_message);
30  }
31 
32  jboolean ret_flag = error_stat->flag;
33  (*env)->SetBooleanField(env, error_structure, paramFlag, ret_flag);
34 }
35 
36 JNIEXPORT jlong JNICALL Java_amns_Amns_ItmAmnsCcSetupReactants(JNIEnv *env, jobject obj, jint idx) {
37  void *reactant_handle;
38  ITM_AMNS_CC_SETUP_REACTANTS(&reactant_handle, "", idx, 1);
39  // DEBUG printf("[JNI] After calling ITM_AMNS_CC_SETUP_REACTANTS\n");
40  // DEBUG printf("[JNI] Pointer: %lu\n", (long)reactant_handle);
41  return (long)reactant_handle;
42 }
43 
44 JNIEXPORT jlong JNICALL Java_amns_Amns_ItmAmnsCcSetupReactantsNumber(JNIEnv *env, jobject obj, jint idx, jint number) {
45  void *reactant_handle;
46  // DEBUG printf("[JNI] Calling ITM_AMNS_CC_SETUP_REACTANTS with number of reactions: %d\n", number);
47  ITM_AMNS_CC_SETUP_REACTANTS(&reactant_handle, "", idx, number);
48  // DEBUG printf("[JNI] After calling ITM_AMNS_CC_SETUP_REACTANTS\n");
49  // DEBUG printf("[JNI] Pointer: %lu\n", (long)reactant_handle);
50  return (long)reactant_handle;
51 }
52 
53 
54 JNIEXPORT void JNICALL Java_amns_Amns_ItmAmnsCCSetReactant(JNIEnv *env, jobject obj, jlong ptr, jobject acrt) {
55 
56  void *reactant_handle = (void*) ptr;
57 
58  amns_c_reactant_type species = DEFAULT_AMNS_C_REACTANT_TYPE;
59 
60  jclass cls = (*env)->GetObjectClass(env, acrt);
61  jfieldID paramZN = (*env)->GetFieldID(env, cls, "ZN", "D");
62  jfieldID paramZA = (*env)->GetFieldID(env, cls, "ZA", "D");
63  jfieldID paramMI = (*env)->GetFieldID(env, cls, "MI", "D");
64  jfieldID paramLR = (*env)->GetFieldID(env, cls, "LR", "I");
65  jfieldID paramRealSpecifier = (*env)->GetFieldID(env, cls, "real_specifier", "D");
66  jfieldID paramIntSpecifier = (*env)->GetFieldID(env, cls, "int_specifier", "I");
67 
68  jdouble zn = (*env)->GetDoubleField(env, acrt, paramZN);
69  jdouble za = (*env)->GetDoubleField(env, acrt, paramZA);
70  jdouble mi = (*env)->GetDoubleField(env, acrt, paramMI);
71  jint lr = (*env)->GetIntField(env, acrt, paramLR);
72  jdouble rs = (*env)->GetDoubleField(env, acrt, paramRealSpecifier);
73  jint int_spec = (*env)->GetIntField(env, acrt, paramIntSpecifier);
74 
75  // DEBUG printf("[JNI] Values from Java: %f:%f:%f:%i:%f:%i\n", zn, za, mi, lr, rs, int_spec);
76 
77  species.ZN=zn; species.ZA=za; species.MI=mi; species.LR=lr; species.real_specifier=rs; species.int_specifier=int_spec;
78  ITM_AMNS_CC_SET_REACTANT(reactant_handle, 1, &species);
79  // DEBUG printf("[JNI] After calling ITM_AMNS_CC_SET_REACTANT\n");
80 }
81 
82 JNIEXPORT void JNICALL Java_amns_Amns_ItmAmnsCCSetReactantIdx(
83  JNIEnv *env,
84  jobject obj,
85  jlong ptr,
86  jint idx,
87  jobject acrt) {
88 
89  void *reactant_handle = (void*) ptr;
90 
91  amns_c_reactant_type species = DEFAULT_AMNS_C_REACTANT_TYPE;
92 
93  jclass cls = (*env)->GetObjectClass(env, acrt);
94  jfieldID paramZN = (*env)->GetFieldID(env, cls, "ZN", "D");
95  jfieldID paramZA = (*env)->GetFieldID(env, cls, "ZA", "D");
96  jfieldID paramMI = (*env)->GetFieldID(env, cls, "MI", "D");
97  jfieldID paramLR = (*env)->GetFieldID(env, cls, "LR", "I");
98  jfieldID paramRealSpecifier = (*env)->GetFieldID(env, cls, "real_specifier", "D");
99  jfieldID paramIntSpecifier = (*env)->GetFieldID(env, cls, "int_specifier", "I");
100 
101  jdouble zn = (*env)->GetDoubleField(env, acrt, paramZN);
102  jdouble za = (*env)->GetDoubleField(env, acrt, paramZA);
103  jdouble mi = (*env)->GetDoubleField(env, acrt, paramMI);
104  jint lr = (*env)->GetIntField(env, acrt, paramLR);
105  jdouble rs = (*env)->GetDoubleField(env, acrt, paramRealSpecifier);
106  jint int_spec = (*env)->GetIntField(env, acrt, paramIntSpecifier);
107 
108  // DEBUG printf("[JNI] Values from Java: %f:%f:%f:%i:%f:%i\n", zn, za, mi, lr, rs, int_spec);
109 
110  species.ZN=zn; species.ZA=za; species.MI=mi; species.LR=lr; species.real_specifier=rs; species.int_specifier=int_spec;
111  // DEBUG printf("[JNI] Calling ITM_AMNS_CC_SET_REACTANT with index: %d\n", idx);
112  ITM_AMNS_CC_SET_REACTANT(reactant_handle, idx, &species);
113  // DEBUG printf("[JNI] After calling ITM_AMNS_CC_SET_REACTANT\n");
114 }
115 
116 JNIEXPORT void JNICALL Java_amns_Amns_ItmAmnsCCGetReactant(JNIEnv *env, jobject obj, jlong ptr, jobject jSpecies) {
117 
118  void *reactant_handle = (void*) ptr;
119 
120  amns_c_reactant_type species = DEFAULT_AMNS_C_REACTANT_TYPE;
121 
122  // at first, get all elements of the species
123  jclass cls = (*env)->GetObjectClass(env, jSpecies);
124  jfieldID paramZN = (*env)->GetFieldID(env, cls, "ZN", "D");
125  jfieldID paramZA = (*env)->GetFieldID(env, cls, "ZA", "D");
126  jfieldID paramMI = (*env)->GetFieldID(env, cls, "MI", "D");
127  jfieldID paramLR = (*env)->GetFieldID(env, cls, "LR", "I");
128  jfieldID paramRealSpecifier = (*env)->GetFieldID(env, cls, "real_specifier", "D");
129  jfieldID paramIntSpecifier = (*env)->GetFieldID(env, cls, "int_specifier", "I");
130 
131  // retrieve data into C structure
132  ITM_AMNS_CC_GET_REACTANT(reactant_handle, 1, &species);
133  // DEBUG printf("[JNI] After calling ITM_AMNS_CC_GET_REACTANTS\n");
134 
135  // copy data back to Java
136  (*env)->SetDoubleField(env, jSpecies, paramZN, (jdouble)species.ZN );
137  (*env)->SetDoubleField(env, jSpecies, paramZA, species.ZA );
138  (*env)->SetDoubleField(env, jSpecies, paramMI, species.MI );
139  (*env)->SetIntField(env, jSpecies, paramLR, species.LR );
140  (*env)->SetDoubleField(env, jSpecies, paramRealSpecifier, species.real_specifier);
141  (*env)->SetIntField(env, jSpecies, paramIntSpecifier, species.int_specifier);
142 }
143 
144 
145 /*
146 
147 This function calls ITM_AMNS_CC_SETUP
148 
149 it returns pointer to amns_handle structure and error_stat structure
150 
151 */
152 JNIEXPORT long JNICALL Java_amns_Amns_ItmAmnsCCSetup(JNIEnv *env, jobject obj, jobject error_structure) {
153  void* amns_handle = NULL;
154  amns_c_error_type error_stat = DEFAULT_AMNS_C_ERROR_TYPE;
155 
156  // DEBUG printf("[JNI] Before calling ITM_AMNS_CC_SETUP\n");
157  ITM_AMNS_CC_SETUP(&amns_handle, &error_stat);
158  // DEBUG printf("[JNI] After calling ITM_AMNS_CC_SETUP\n");
159  // DEBUG printf("[JNI] Pointer: %lu\n", (long)amns_handle);
160 
161  copyCError2JavaError( &error_stat, env, error_structure );
162 
163  return (long) amns_handle;
164 }
165 
166 JNIEXPORT jlong JNICALL Java_amns_Amns_ItmAmnsCCSetupTable(
167  JNIEnv *env
168  , jobject obj
169  , jlong ptr_amns_handle
170  , jobject j_reaction_type
171  , jlong ptr_reactants_handle
172  , jobject j_error_state) {
173  // declare structures used in call
174  amns_c_error_type error_stat = DEFAULT_AMNS_C_ERROR_TYPE;
175  void* amns_cx_handle;
176  amns_c_reaction_type xx_rx;
177 
178  // get pointers
179  void *amns_handle = (void*) ptr_amns_handle;
180  void *reactants_handle = (void*) ptr_reactants_handle;
181 
182  // retrieve and copy values from reaction_type object
183  jclass cls = (*env)->GetObjectClass(env, j_reaction_type);
184  jfieldID paramString = (*env)->GetFieldID(env, cls, "string", "Ljava/lang/String;");
185  jfieldID paramIsotope = (*env)->GetFieldID(env, cls, "isotopeResolved", "I");
186 
187  jstring j_reaction_string = (*env)->GetObjectField(env, j_reaction_type, paramString);
188  jint j_reaction_isotope = (*env)->GetIntField(env, j_reaction_type, paramIsotope);
189 
190  char *reaction_string = (char*) (*env)->GetStringUTFChars(env, j_reaction_string, NULL);
191  int reaction_isotope = (int) j_reaction_isotope;
192 
193  xx_rx.string = reaction_string;
194  xx_rx.isotope_resolved = reaction_isotope;
195 
196  // DEBUG printf("[JNI] Reaction type = %s, %u\n", xx_rx.string, xx_rx.isotope_resolved);
197 
198  // we can now call C function
199  // note that we will return amns_cx_handle as return value from function
200  // DEBUG printf("[JNI] Before calling ITM_AMNS_CC_SETUP_TABLE\n");
201  // DEBUG printf("[JNI] amns_handle pointer: %lu\n", (long)amns_handle);
202  // DEBUG printf("[JNI] reactants_handle pointer: %lu\n", (long)reactants_handle);
203  ITM_AMNS_CC_SETUP_TABLE(amns_handle, &xx_rx, reactants_handle, &amns_cx_handle, &error_stat);
204 
205  // DEBUG printf("[JNI] After calling ITM_AMNS_CC_SETUP_TABLE\n");
206  // DEBUG printf("[JNI] reaction_handle pointer: %lu\n", (long)amns_cx_handle);
207 
208  // we have to make sure that error_stat is passed back inside object
209 
210  copyCError2JavaError( &error_stat, env, j_error_state);
211 
212  // remember to release string
213  (*env)->ReleaseStringUTFChars(env, j_reaction_string, reaction_string);
214 
215  return (long) amns_cx_handle;
216 }
217 
218 JNIEXPORT jdouble JNICALL Java_amns_Amns_ItmAmnsCCRX0B(
219  JNIEnv *env
220  , jobject obj
221  , jlong ptrHandleRx
222  , double j_arg1
223  , double j_arg2
224  , jobject j_error_state ) {
225 
226  amns_c_error_type error_stat = DEFAULT_AMNS_C_ERROR_TYPE;
227  void* amns_cx_handle = (void *) ptrHandleRx;
228  double arg1 = (double) j_arg1;
229  double arg2 = (double) j_arg2;
230  double rate;
231 
232  // DEBUG printf("[JNI] Before calling ITM_AMNS_CC_RX_0_B\n");
233  // DEBUG printf("[JNI] cx_handle: %x, arg1: %e, arg2: %e\n", ptrHandleRx, arg1, arg2);
234  ITM_AMNS_CC_RX_0_B(amns_cx_handle, &rate, arg1, arg2, &error_stat);
235  // DEBUG printf("[JNI] After calling ITM_AMNS_CC_RX_0_B\n");
236  // DEBUG printf("[JNI] rate: %e\n", rate);
237 
238  // we have to make sure that error_stat is passed back inside object
239 
240  copyCError2JavaError( &error_stat, env, j_error_state);
241 
242  return (jdouble) rate;
243 
244 }
245 
246 JNIEXPORT long JNICALL Java_amns_Amns_ItmAmnsCCFinishTable(
247  JNIEnv *env
248  , jobject obj
249  , jlong ptrHandleRX
250  , jobject j_error_state) {
251 
252  amns_c_error_type error_stat = DEFAULT_AMNS_C_ERROR_TYPE;
253  void* amns_cx_handle = (void *) ptrHandleRX;
254 
255  // DEBUG printf("[JNI] Before calling ITM_AMNS_CC_FINISH_TABLE\n");
256  // DEBUG printf("[JNI] cx_handle: %lu\n", (long)ptrHandleRX);
257  ITM_AMNS_CC_FINISH_TABLE(&amns_cx_handle, &error_stat);
258  // DEBUG printf("[JNI] After calling ITM_AMNS_CC_FINISH_TABLE\n");
259 
260  // we have to make sure that error_stat is passed back inside object
261 
262  copyCError2JavaError( &error_stat, env, j_error_state );
263 
264  return (jlong) amns_cx_handle;
265 
266 }
267 
268 JNIEXPORT jlong JNICALL Java_amns_Amns_ItmAmnsCCFinishReactants(
269  JNIEnv *env
270  , jobject obj
271  , jlong ptr_reactants_handle) {
272 
273  void* reactants_handle = (void *) ptr_reactants_handle;
274 
275  // DEBUG printf("[JNI] Before calling ITM_AMNS_CC_FINISH_REACTANTS\n");
276  // DEBUG printf("[JNI] reactants_handle: %lu\n", (long)ptr_reactants_handle);
277  ITM_AMNS_CC_FINISH_REACTANTS(&reactants_handle);
278  // DEBUG printf("[JNI] After calling ITM_AMNS_CC_FINISH_REACTANTS\n");
279 
280  return (long) reactants_handle;
281 }
282 
283 
284 JNIEXPORT jlong JNICALL Java_amns_Amns_ItmAmnsCCFinish(
285  JNIEnv *env
286  , jobject obj
287  , jlong ptr_amns_handle
288  , jobject j_error_state) {
289 
290  amns_c_error_type error_stat = DEFAULT_AMNS_C_ERROR_TYPE;
291  void* amns_handle = (void*) ptr_amns_handle;
292 
293  // DEBUG printf("[JNI] Before calling ITM_AMNS_CC_FINISH\n");
294  // DEBUG printf("[JNI] amns_handle: %lu\n", (long)ptr_amns_handle);
295  ITM_AMNS_CC_FINISH(&amns_handle, &error_stat);
296  // DEBUG printf("[JNI] After calling ITM_AMNS_CC_FINISH\n");
297 
298  // we have to make sure that error_stat is passed back inside object
299 
300  copyCError2JavaError( &error_stat, env, j_error_state);
301 
302  return (long) amns_handle;
303 
304 }
305 
306 JNIEXPORT void JNICALL Java_amns_Amns_ItmAmnsCCSet(
307  JNIEnv *env
308  , jobject obj
309  , jlong ptrAmnsHandle
310  , jobject j_amns_set_type
311  , jobject j_error_state) {
312 
313  amns_c_set_type set = DEFAULT_AMNS_C_SET_TYPE;
314  amns_c_error_type error_stat = DEFAULT_AMNS_C_ERROR_TYPE;
315  void *amns_handler = (void *) ptrAmnsHandle;
316 
317  jclass cls = (*env)->GetObjectClass(env, j_amns_set_type);
318  jfieldID paramString = (*env)->GetFieldID(env, cls, "string", "Ljava/lang/String;");
319 
320  jstring j_set_type_string = (*env)->GetObjectField(env, j_amns_set_type, paramString);
321 
322  char *set_type_string = (char*)(*env)->GetStringUTFChars(env, j_set_type_string, NULL);
323 
324  set.string = set_type_string;
325 
326  // DEBUG printf("[JNI] Before calling ITM_AMNS_CC_SET\n");
327  // DEBUG printf("[JNI] amns_handle: %lu\n", (long)ptrAmnsHandle);
328  ITM_AMNS_CC_SET(amns_handler, &set, &error_stat);
329  // DEBUG printf("[JNI] After calling ITM_AMNS_CC_SET\n");
330 
331  copyCError2JavaError( &error_stat, env, j_error_state);
332 
333  (*env)->ReleaseStringUTFChars(env, j_set_type_string, set_type_string);
334 
335 }
336 
337 JNIEXPORT void JNICALL Java_amns_Amns_ItmAmnsCCQuery(
338  JNIEnv *env
339  , jobject obj
340  , jlong ptrAmnsHandle
341  , jobject j_amns_query
342  , jobject j_amns_answer
343  , jobject j_error_state) {
344 
345  amns_c_error_type error_stat = DEFAULT_AMNS_C_ERROR_TYPE;
346  amns_c_query_type query = DEFAULT_AMNS_C_QUERY_TYPE;
347  amns_c_answer_type answer = DEFAULT_AMNS_C_ANSWER_TYPE;
348  void *amns_handler = (void *) ptrAmnsHandle;
349 
350  // we have to retrieve the query and pass it to function
351 
352  jclass cls = (*env)->GetObjectClass(env, j_amns_query);
353  jfieldID paramString = (*env)->GetFieldID(env, cls, "string", "Ljava/lang/String;");
354 
355  jstring j_query_string = (*env)->GetObjectField(env, j_amns_query, paramString);
356 
357  char *query_string = (char*)(*env)->GetStringUTFChars(env, j_query_string, NULL);
358 
359  query.string = query_string;
360 
361  // DEBUG printf("[JNI] Before calling ITM_AMNS_CC_QUERY\n");
362  // DEBUG printf("[JNI] amns_handle: %lu\n", (long)ptrAmnsHandle);
363  ITM_AMNS_CC_QUERY(amns_handler, &query, &answer, &error_stat);
364  // DEBUG printf("[JNI] After calling ITM_AMNS_CC_QUERY\n");
365 
366  // copy error to Java
367  copyCError2JavaError( &error_stat, env, j_error_state);
368 
369  // copy answer to Java
370 
371  jclass cls_answer = (*env)->GetObjectClass(env, j_amns_answer);
372  jfieldID answerNumber = (*env)->GetFieldID(env, cls_answer, "number", "I");
373  jfieldID answerString = (*env)->GetFieldID(env, cls_answer, "string", "Ljava/lang/String;");
374 
375  jstring answer_value;
376 
377  if(answer.string != NULL) {
378  answer_value = (*env)->NewStringUTF(env,answer.string);
379  } else {
380  answer_value = (*env)->NewStringUTF(env,"");
381  }
382  if(answer_value == NULL) {
383  (*env)->SetObjectField(env, j_amns_answer, answerString, "");
384  } else {
385  (*env)->SetObjectField(env, j_amns_answer, answerString, answer_value);
386  }
387 
388  jint answer_number = answer.number;
389  (*env)->SetIntField(env, j_amns_answer, answerNumber, answer_number);
390 }
391 
392 JNIEXPORT void JNICALL Java_amns_Amns_ItmAmnsCCQueryTable(
393  JNIEnv *env
394  , jobject obj
395  , jlong ptrTableHandle
396  , jobject j_amns_query
397  , jobject j_amns_answer
398  , jobject j_error_state) {
399 
400  amns_c_error_type error_stat = DEFAULT_AMNS_C_ERROR_TYPE;
401  amns_c_query_type query = DEFAULT_AMNS_C_QUERY_TYPE;
402  amns_c_answer_type answer = DEFAULT_AMNS_C_ANSWER_TYPE;
403  void *table_handler = (void *) ptrTableHandle;
404 
405  // we have to retrieve the query and pass it to function
406 
407  jclass cls = (*env)->GetObjectClass(env, j_amns_query);
408  jfieldID paramString = (*env)->GetFieldID(env, cls, "string", "Ljava/lang/String;");
409 
410  jstring j_query_string = (*env)->GetObjectField(env, j_amns_query, paramString);
411 
412  char *query_string = (char*)(*env)->GetStringUTFChars(env, j_query_string, NULL);
413 
414  query.string = query_string;
415 
416  // DEBUG printf("[JNI] Before calling ITM_AMNS_CC_QUERY_TABLE\n");
417  // DEBUG printf("[JNI] table_handle: %lu\n", (long)ptrTableHandle);
418  ITM_AMNS_CC_QUERY_TABLE(table_handler, &query, &answer, &error_stat);
419  // DEBUG printf("[JNI] After calling ITM_AMNS_CC_QUERY_TABLE\n");
420 
421  // copy error to Java
422  copyCError2JavaError( &error_stat, env, j_error_state);
423 
424  // copy answer to Java
425 
426  jclass cls_answer = (*env)->GetObjectClass(env, j_amns_answer);
427  jfieldID answerNumber = (*env)->GetFieldID(env, cls_answer, "number", "I");
428  jfieldID answerString = (*env)->GetFieldID(env, cls_answer, "string", "Ljava/lang/String;");
429 
430  jstring answer_value;
431 
432  if(answer.string != NULL) {
433  answer_value = (*env)->NewStringUTF(env,answer.string);
434  } else {
435  answer_value = (*env)->NewStringUTF(env,"");
436  }
437  if(answer_value == NULL) {
438  (*env)->SetObjectField(env, j_amns_answer, answerString, "");
439  } else {
440  (*env)->SetObjectField(env, j_amns_answer, answerString, answer_value);
441  }
442 
443  jint answer_number = answer.number;
444  (*env)->SetIntField(env, j_amns_answer, answerNumber, answer_number);
445 }
446 
447 JNIEXPORT jdoubleArray JNICALL Java_amns_Amns_ItmAmnsCCRX1A(
448  JNIEnv *env,
449  jobject obj,
450  jlong ptrHandleRx,
451  jint nx,
452  jdoubleArray j_arg1,
453  jobject j_error_state) {
454 
455  amns_c_error_type error_stat = DEFAULT_AMNS_C_ERROR_TYPE;
456  void *handle_rx_in = (void *) ptrHandleRx;
457 
458  jsize len_arr1 = (*env)->GetArrayLength(env, j_arg1);
459  jdouble *arg1 = (*env)->GetDoubleArrayElements(env, j_arg1, 0);
460 
461  double *outputArray = (double *) malloc(nx * sizeof(double));
462 
463  // DEBUG printf("[JNI] Before calling ITM_AMNS_CC_RX_1_A\n");
464  // DEBUG printf("[JNI] table_handle: %lu\n", (long)handle_rx_in);
465  ITM_AMNS_CC_RX_1_A(handle_rx_in, nx, outputArray, arg1, &error_stat);
466  // DEBUG printf("[JNI] After calling ITM_AMNS_CC_RX_1_A\n");
467 
468  // copy error to Java
469  copyCError2JavaError( &error_stat, env, j_error_state);
470 
471  jdoubleArray outJNIArray = (*env)->NewDoubleArray(env, nx);
472  if (NULL == outJNIArray) {
473  return NULL;
474  }
475  (*env)->SetDoubleArrayRegion(env, outJNIArray, 0 , nx, outputArray);
476 
477  return outJNIArray;
478 }
479 
480 JNIEXPORT jdoubleArray JNICALL Java_amns_Amns_ItmAmnsCCRX1B(
481  JNIEnv *env,
482  jobject obj,
483  jlong ptrHandleRx,
484  jint nx,
485  jdoubleArray j_arg1,
486  jdoubleArray j_arg2,
487  jobject j_error_state) {
488 
489  amns_c_error_type error_stat = DEFAULT_AMNS_C_ERROR_TYPE;
490  void *handle_rx_in = (void *) ptrHandleRx;
491 
492  jsize len_arr1 = (*env)->GetArrayLength(env, j_arg1);
493  jdouble *arg1 = (*env)->GetDoubleArrayElements(env, j_arg1, 0);
494 
495  jsize len_arr2 = (*env)->GetArrayLength(env, j_arg2);
496  jdouble *arg2 = (*env)->GetDoubleArrayElements(env, j_arg2, 0);
497 
498  double *outputArray = (double *) malloc(nx * sizeof(double));
499 
500  // DEBUG printf("[JNI] Before calling ITM_AMNS_CC_RX_1_B\n");
501  // DEBUG printf("[JNI] table_handle: %lu\n", (long)handle_rx_in);
502 
503  /*printf("--- JNI CODE - arg1 - start ---\n");
504  int ii=0;
505  for(ii=0; ii<nx; ii++ ) {
506  printf("%1.6f ", arg1[ii]);
507  }
508  printf("\n");
509  printf("--- JNI CODE - end ---\n");
510  fflush(stdout);
511  printf("--- JNI CODE - arg2 - start ---\n");
512  for(ii=0; ii<nx; ii++ ) {
513  printf("%1.6f ", arg2[ii]);
514  }
515  printf("\n");
516  printf("--- JNI CODE - end ---\n");
517  fflush(stdout);*/
518 
519  ITM_AMNS_CC_RX_1_B(handle_rx_in, nx, outputArray, arg1, arg2, &error_stat);
520  // DEBUG printf("[JNI] After calling ITM_AMNS_CC_RX_1_B\n");
521 
522  // copy error to Java
523  copyCError2JavaError( &error_stat, env, j_error_state);
524 
525  jdoubleArray outJNIArray = (*env)->NewDoubleArray(env, nx);
526  if (NULL == outJNIArray) {
527  return NULL;
528  }
529  (*env)->SetDoubleArrayRegion(env, outJNIArray, 0 , nx, outputArray);
530 
531  return outJNIArray;
532 
533 }
534 
535 JNIEXPORT jdoubleArray JNICALL Java_amns_Amns_ItmAmnsCCRX1C(
536  JNIEnv *env,
537  jobject obj,
538  jlong ptrHandleRx,
539  jint nx,
540  jdoubleArray j_arg1,
541  jdoubleArray j_arg2,
542  jdoubleArray j_arg3,
543  jobject j_error_state) {
544 
545  amns_c_error_type error_stat = DEFAULT_AMNS_C_ERROR_TYPE;
546  void *handle_rx_in = (void *) ptrHandleRx;
547 
548 
549  jsize len_arr1 = (*env)->GetArrayLength(env, j_arg1);
550  jdouble *arg1 = (*env)->GetDoubleArrayElements(env, j_arg1, 0);
551 
552  jsize len_arr2 = (*env)->GetArrayLength(env, j_arg2);
553  jdouble *arg2 = (*env)->GetDoubleArrayElements(env, j_arg2, 0);
554 
555  jsize len_arr3 = (*env)->GetArrayLength(env, j_arg3);
556  jdouble *arg3 = (*env)->GetDoubleArrayElements(env, j_arg3, 0);
557 
558  double *outputArray = (double *) malloc(nx * sizeof(double));
559 
560  // DEBUG printf("[JNI] Before calling ITM_AMNS_CC_RX_1_C\n");
561  // DEBUG printf("[JNI] table_handle: %lu\n", (long)handle_rx_in);
562  ITM_AMNS_CC_RX_1_C(handle_rx_in, nx, outputArray, arg1, arg2, arg3, &error_stat);
563  // DEBUG printf("[JNI] After calling ITM_AMNS_CC_RX_1_C\n");
564 
565  // copy error to Java
566  copyCError2JavaError( &error_stat, env, j_error_state);
567 
568  jdoubleArray outJNIArray = (*env)->NewDoubleArray(env, nx);
569  if (NULL == outJNIArray) {
570  return NULL;
571  }
572  (*env)->SetDoubleArrayRegion(env, outJNIArray, 0 , nx, outputArray);
573 
574  return outJNIArray;
575 
576 }
577 
578 JNIEXPORT void JNICALL Java_amns_Amns_ItmAmnsCCSetTable(
579  JNIEnv *env,
580  jobject obj,
581  jlong ptrAmnsCxHandle,
582  jobject j_amns_set_type,
583  jobject j_error_state) {
584  amns_c_set_type set = DEFAULT_AMNS_C_SET_TYPE;
585  amns_c_error_type error_stat = DEFAULT_AMNS_C_ERROR_TYPE;
586  void *amns_cx_handler = (void *) ptrAmnsCxHandle;
587 
588  jclass cls = (*env)->GetObjectClass(env, j_amns_set_type);
589  jfieldID paramString = (*env)->GetFieldID(env, cls, "string", "Ljava/lang/String;");
590 
591  jstring j_set_type_string = (*env)->GetObjectField(env, j_amns_set_type, paramString);
592 
593  char *set_type_string = (char*)(*env)->GetStringUTFChars(env, j_set_type_string, NULL);
594 
595  set.string = set_type_string;
596 
597  // DEBUG printf("[JNI] Before calling ITM_AMNS_CC_SET_TABLE\n");
598  // DEBUG printf("[JNI] amns_cx_handle: %lu\n", (long)ptrAmnsCxHandle);
599  ITM_AMNS_CC_SET_TABLE(amns_cx_handler, &set, &error_stat);
600  // DEBUG printf("[JNI] After calling ITM_AMNS_CC_SET_TABLE\n");
601 
602  copyCError2JavaError( &error_stat, env, j_error_state);
603 
604  (*env)->ReleaseStringUTFChars(env, j_set_type_string, set_type_string);
605 }
amns_jni_call.h
Java_amns_Amns_ItmAmnsCCSetTable
JNIEXPORT void JNICALL Java_amns_Amns_ItmAmnsCCSetTable(JNIEnv *env, jobject obj, jlong ptrAmnsCxHandle, jobject j_amns_set_type, jobject j_error_state)
Definition: amns_jni_call.c:578
amns_c_answer_type::string
char * string
string version of the answer to a query
Definition: amns_interface.h:262
ITM_AMNS_CC_SET_TABLE
void ITM_AMNS_CC_SET_TABLE(void *handle_rx_in, amns_c_set_type *set, amns_c_error_type *error_status)
Definition: amns_interface.h:454
ITM_AMNS_CC_RX_1_B
void ITM_AMNS_CC_RX_1_B(void *handle_rx_in, int nx, double *out, double *arg1, double *arg2, amns_c_error_type *error_status)
Definition: amns_interface.h:492
copyCError2JavaError
void copyCError2JavaError(amns_c_error_type *error_stat, JNIEnv *env, jobject error_structure)
Definition: amns_jni_call.c:9
amns_c_answer_type::number
int number
integer version of the answer to a query
Definition: amns_interface.h:263
amns_c_set_type::string
char * string
used to pass a change in the settings
Definition: amns_interface.h:207
amns_c_error_type
Type for error returns from the AMNS interface (&quot;C&quot; version)
Definition: amns_interface.h:133
amns_c_query_type
Type for querying parameters in the AMNS package (&quot;C&quot; version)
Definition: amns_interface.h:233
query
if error_status & query
Definition: amns.pyx:11
DEFAULT_AMNS_C_SET_TYPE
const amns_c_set_type DEFAULT_AMNS_C_SET_TYPE
Definition: amns_interface.h:211
DEFAULT_AMNS_C_ERROR_TYPE
const amns_c_error_type DEFAULT_AMNS_C_ERROR_TYPE
Definition: amns_interface.h:139
answer
if error_status & answer
Definition: amns.pyx:11
Java_amns_Amns_ItmAmnsCcSetupReactantsNumber
JNIEXPORT jlong JNICALL Java_amns_Amns_ItmAmnsCcSetupReactantsNumber(JNIEnv *env, jobject obj, jint idx, jint number)
Definition: amns_jni_call.c:44
DEFAULT_AMNS_C_REACTANT_TYPE
const amns_c_reactant_type DEFAULT_AMNS_C_REACTANT_TYPE
Definition: amns_interface.h:112
amns_reactant_type::MI
double MI
Atomic mass.
Definition: amns_interface.h:103
amns_c_answer_type
Type for answers from queries in the AMNS package (&quot;C&quot; version)
Definition: amns_interface.h:261
DEFAULT_AMNS_C_ANSWER_TYPE
const amns_c_answer_type DEFAULT_AMNS_C_ANSWER_TYPE
Definition: amns_interface.h:267
ITM_AMNS_CC_FINISH_TABLE
void ITM_AMNS_CC_FINISH_TABLE(void **handle_rx_inout, amns_c_error_type *error_status)
Definition: amns_interface.h:401
Java_amns_Amns_ItmAmnsCCRX1B
JNIEXPORT jdoubleArray JNICALL Java_amns_Amns_ItmAmnsCCRX1B(JNIEnv *env, jobject obj, jlong ptrHandleRx, jint nx, jdoubleArray j_arg1, jdoubleArray j_arg2, jobject j_error_state)
Definition: amns_jni_call.c:480
amns_c_reaction_type
Type used for specifying reactions when using the AMNS interface (&quot;C&quot; version)
Definition: amns_interface.h:170
amns_c_reaction_type::string
char * string
name of the reaction (e.g. RC)
Definition: amns_interface.h:171
Java_amns_Amns_ItmAmnsCCRX1A
JNIEXPORT jdoubleArray JNICALL Java_amns_Amns_ItmAmnsCCRX1A(JNIEnv *env, jobject obj, jlong ptrHandleRx, jint nx, jdoubleArray j_arg1, jobject j_error_state)
Definition: amns_jni_call.c:447
ITM_AMNS_CC_FINISH_REACTANTS
void ITM_AMNS_CC_FINISH_REACTANTS(void **reactants_handle_inout)
Definition: amns_interface.h:564
Java_amns_Amns_ItmAmnsCCSetupTable
JNIEXPORT jlong JNICALL Java_amns_Amns_ItmAmnsCCSetupTable(JNIEnv *env, jobject obj, jlong ptr_amns_handle, jobject j_reaction_type, jlong ptr_reactants_handle, jobject j_error_state)
Definition: amns_jni_call.c:166
amns_reactant_type::real_specifier
double real_specifier
a place holder to specify an optional real further characterising a reactant/product ...
Definition: amns_interface.h:105
Java_amns_Amns_ItmAmnsCCSetup
JNIEXPORT long JNICALL Java_amns_Amns_ItmAmnsCCSetup(JNIEnv *env, jobject obj, jobject error_structure)
Definition: amns_jni_call.c:152
Java_amns_Amns_ItmAmnsCCFinishReactants
JNIEXPORT jlong JNICALL Java_amns_Amns_ItmAmnsCCFinishReactants(JNIEnv *env, jobject obj, jlong ptr_reactants_handle)
Definition: amns_jni_call.c:268
ITM_AMNS_CC_RX_1_C
void ITM_AMNS_CC_RX_1_C(void *handle_rx_in, int nx, double *out, double *arg1, double *arg2, double *arg3, amns_c_error_type *error_status)
Definition: amns_interface.h:499
amns_c_set_type
Type for setting parameters in the AMNS package (&quot;C&quot; version)
Definition: amns_interface.h:206
ITM_AMNS_CC_QUERY_TABLE
void ITM_AMNS_CC_QUERY_TABLE(void *handle_rx_in, amns_c_query_type *query, amns_c_answer_type *answer, amns_c_error_type *error_status)
Definition: amns_interface.h:441
ITM_AMNS_CC_FINISH
void ITM_AMNS_CC_FINISH(void **handle_inout, amns_c_error_type *error_status)
Definition: amns_interface.h:394
Java_amns_Amns_ItmAmnsCCGetReactant
JNIEXPORT void JNICALL Java_amns_Amns_ItmAmnsCCGetReactant(JNIEnv *env, jobject obj, jlong ptr, jobject jSpecies)
Definition: amns_jni_call.c:116
Java_amns_Amns_ItmAmnsCCSetReactant
JNIEXPORT void JNICALL Java_amns_Amns_ItmAmnsCCSetReactant(JNIEnv *env, jobject obj, jlong ptr, jobject acrt)
Definition: amns_jni_call.c:54
ITM_AMNS_CC_GET_REACTANT
void ITM_AMNS_CC_GET_REACTANT(void *reactants_handle_in, int reactant_index, amns_c_reactant_type *reactant_out)
Definition: amns_interface.h:560
amns_c_reaction_type::isotope_resolved
int isotope_resolved
if the reaction is different for different isotopes, isotope_resolved shoukld be set to 1 ...
Definition: amns_interface.h:172
Java_amns_Amns_ItmAmnsCCFinishTable
JNIEXPORT long JNICALL Java_amns_Amns_ItmAmnsCCFinishTable(JNIEnv *env, jobject obj, jlong ptrHandleRX, jobject j_error_state)
Definition: amns_jni_call.c:246
ITM_AMNS_CC_SETUP_REACTANTS
void ITM_AMNS_CC_SETUP_REACTANTS(void **reactants_handle_out, char *string_in, int index_in, int n_reactants)
Definition: amns_interface.h:548
ITM_AMNS_CC_RX_0_B
void ITM_AMNS_CC_RX_0_B(void *handle_rx_in, double *out, double arg1, double arg2, amns_c_error_type *error_status)
Definition: amns_interface.h:471
ITM_AMNS_CC_SET_REACTANT
void ITM_AMNS_CC_SET_REACTANT(void *reactants_handle_in, int reactant_index, amns_c_reactant_type *reactant_in)
Definition: amns_interface.h:555
amns_reactant_type::ZA
double ZA
Atomic charge.
Definition: amns_interface.h:102
ITM_AMNS_CC_SET
void ITM_AMNS_CC_SET(void *handle_in, amns_c_set_type *set, amns_c_error_type *error_status)
Definition: amns_interface.h:408
ITM_AMNS_CC_QUERY
void ITM_AMNS_CC_QUERY(void *handle_in, amns_c_query_type *query, amns_c_answer_type *answer, amns_c_error_type *error_status)
Definition: amns_interface.h:418
amns_c_error_type::flag
bool flag
True if an error occurred.
Definition: amns_interface.h:134
DEFAULT_AMNS_C_QUERY_TYPE
const amns_c_query_type DEFAULT_AMNS_C_QUERY_TYPE
Definition: amns_interface.h:238
amns_reactant_type::ZN
double ZN
Nuclear charge.
Definition: amns_interface.h:101
amns_reactant_type
Type for indicating a single reactant or product when using the AMNS interface.
Definition: amns_interface.h:100
Java_amns_Amns_ItmAmnsCCSet
JNIEXPORT void JNICALL Java_amns_Amns_ItmAmnsCCSet(JNIEnv *env, jobject obj, jlong ptrAmnsHandle, jobject j_amns_set_type, jobject j_error_state)
Definition: amns_jni_call.c:306
Java_amns_Amns_ItmAmnsCCSetReactantIdx
JNIEXPORT void JNICALL Java_amns_Amns_ItmAmnsCCSetReactantIdx(JNIEnv *env, jobject obj, jlong ptr, jint idx, jobject acrt)
Definition: amns_jni_call.c:82
Java_amns_Amns_ItmAmnsCCQueryTable
JNIEXPORT void JNICALL Java_amns_Amns_ItmAmnsCCQueryTable(JNIEnv *env, jobject obj, jlong ptrTableHandle, jobject j_amns_query, jobject j_amns_answer, jobject j_error_state)
Definition: amns_jni_call.c:392
Java_amns_Amns_ItmAmnsCCFinish
JNIEXPORT jlong JNICALL Java_amns_Amns_ItmAmnsCCFinish(JNIEnv *env, jobject obj, jlong ptr_amns_handle, jobject j_error_state)
Definition: amns_jni_call.c:284
Java_amns_Amns_ItmAmnsCCQuery
JNIEXPORT void JNICALL Java_amns_Amns_ItmAmnsCCQuery(JNIEnv *env, jobject obj, jlong ptrAmnsHandle, jobject j_amns_query, jobject j_amns_answer, jobject j_error_state)
Definition: amns_jni_call.c:337
ITM_AMNS_CC_SETUP_TABLE
void ITM_AMNS_CC_SETUP_TABLE(void *handle_in, amns_c_reaction_type *reaction_type, void *reactant_handle_in, void **handle_rx_out, amns_c_error_type *error_status)
Definition: amns_interface.h:431
amns_c_error_type::string
char * string
text describing the error if flag was True
Definition: amns_interface.h:135
amns_reactant_type::int_specifier
int int_specifier
a place holder to specify an optional integer further characterising a reactant/product ...
Definition: amns_interface.h:106
Java_amns_Amns_ItmAmnsCcSetupReactants
JNIEXPORT jlong JNICALL Java_amns_Amns_ItmAmnsCcSetupReactants(JNIEnv *env, jobject obj, jint idx)
Definition: amns_jni_call.c:36
amns_c_query_type::string
char * string
used to pass a query about settings
Definition: amns_interface.h:234
amns_reactant_type::LR
int LR
reactant (LR=0) or product (LR=1)
Definition: amns_interface.h:104
ITM_AMNS_CC_RX_1_A
void ITM_AMNS_CC_RX_1_A(void *handle_rx_in, int nx, double *out, double *arg1, amns_c_error_type *error_status)
Definition: amns_interface.h:485
ITM_AMNS_CC_SETUP
void ITM_AMNS_CC_SETUP(void **handle_out, amns_c_error_type *error_status)
Definition: amns_interface.h:377
Java_amns_Amns_ItmAmnsCCRX1C
JNIEXPORT jdoubleArray JNICALL Java_amns_Amns_ItmAmnsCCRX1C(JNIEnv *env, jobject obj, jlong ptrHandleRx, jint nx, jdoubleArray j_arg1, jdoubleArray j_arg2, jdoubleArray j_arg3, jobject j_error_state)
Definition: amns_jni_call.c:535
Java_amns_Amns_ItmAmnsCCRX0B
JNIEXPORT jdouble JNICALL Java_amns_Amns_ItmAmnsCCRX0B(JNIEnv *env, jobject obj, jlong ptrHandleRx, double j_arg1, double j_arg2, jobject j_error_state)
Definition: amns_jni_call.c:218