1 //
2 // SNAP.cpp
3 //
4 // LGPL Version 2.1 HEADER START
5 //
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 //
9 // License as published by the Free Software Foundation; either
10 // version 2.1 of the License, or (at your option) any later version.
11 //
12 // This library is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 // Lesser General Public License for more details.
16 //
17 // You should have received a copy of the GNU Lesser General Public
18 // License along with this library; if not, write to the Free Software
19 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
20 // MA 02110-1301 USA
21 //
22 // LGPL Version 2.1 HEADER END
23 //
24
25 //
26 // Copyright (c) 2019, Regents of the University of Minnesota.
27 // All rights reserved.
28 //
29 // Contributors:
30 // Ryan S. Elliott
31 // Yaser Afshar
32 //
33
34
35 #include "SNAP.hpp"
36 #include "SNAPImplementation.hpp"
37
38 // The standard interface to KIM Model Drivers
39
40 extern "C"
41 {
model_driver_create(KIM::ModelDriverCreate * const modelDriverCreate,KIM::LengthUnit const requestedLengthUnit,KIM::EnergyUnit const requestedEnergyUnit,KIM::ChargeUnit const requestedChargeUnit,KIM::TemperatureUnit const requestedTemperatureUnit,KIM::TimeUnit const requestedTimeUnit)42 int model_driver_create(KIM::ModelDriverCreate *const modelDriverCreate,
43 KIM::LengthUnit const requestedLengthUnit,
44 KIM::EnergyUnit const requestedEnergyUnit,
45 KIM::ChargeUnit const requestedChargeUnit,
46 KIM::TemperatureUnit const requestedTemperatureUnit,
47 KIM::TimeUnit const requestedTimeUnit)
48 {
49 if (!modelDriverCreate)
50 {
51 HELPER_LOG_ERROR("The ModelDriverCreate pointer is not assigned");
52 return true;
53 }
54
55 int ier;
56
57 // read input files, convert units if needed, compute
58 // interpolation coefficients, set cutoff, and publish parameters
59 SNAP *const modelObject = new SNAP(modelDriverCreate,
60 requestedLengthUnit,
61 requestedEnergyUnit,
62 requestedChargeUnit,
63 requestedTemperatureUnit,
64 requestedTimeUnit,
65 &ier);
66 if (ier)
67 {
68 // constructor has already reported the error
69 delete modelObject;
70 return true;
71 }
72
73 // register pointer to SNAP object in KIM object
74 modelDriverCreate->SetModelBufferPointer(static_cast<void *>(modelObject));
75
76 // everything is good
77 return false;
78 }
79 }
80
81 // Implementation of SNAP public wrapper functions
82
SNAP(KIM::ModelDriverCreate * const modelDriverCreate,KIM::LengthUnit const requestedLengthUnit,KIM::EnergyUnit const requestedEnergyUnit,KIM::ChargeUnit const requestedChargeUnit,KIM::TemperatureUnit const requestedTemperatureUnit,KIM::TimeUnit const requestedTimeUnit,int * const ier)83 SNAP::SNAP(KIM::ModelDriverCreate *const modelDriverCreate,
84 KIM::LengthUnit const requestedLengthUnit,
85 KIM::EnergyUnit const requestedEnergyUnit,
86 KIM::ChargeUnit const requestedChargeUnit,
87 KIM::TemperatureUnit const requestedTemperatureUnit,
88 KIM::TimeUnit const requestedTimeUnit,
89 int *const ier) : snap_implementation(new SNAPImplementation(modelDriverCreate,
90 requestedLengthUnit,
91 requestedEnergyUnit,
92 requestedChargeUnit,
93 requestedTemperatureUnit,
94 requestedTimeUnit,
95 ier)) {}
96
~SNAP()97 SNAP::~SNAP() {}
98
99 // static member function
Destroy(KIM::ModelDestroy * const modelDestroy)100 int SNAP::Destroy(KIM::ModelDestroy *const modelDestroy)
101 {
102 if (!modelDestroy)
103 {
104 HELPER_LOG_ERROR("The ModelDestroy pointer is not assigned");
105 return true;
106 }
107
108 SNAP *modelObject = NULL;
109
110 modelDestroy->GetModelBufferPointer(reinterpret_cast<void **>(&modelObject));
111
112 if (modelObject)
113 {
114 // delete the object itself
115 delete modelObject;
116 }
117
118 // everything is good
119 return false;
120 }
121
122 // static member function
Refresh(KIM::ModelRefresh * const modelRefresh)123 int SNAP::Refresh(KIM::ModelRefresh *const modelRefresh)
124 {
125 if (!modelRefresh)
126 {
127 HELPER_LOG_ERROR("The ModelRefresh pointer is not assigned");
128 return true;
129 }
130
131 SNAP *modelObject = NULL;
132
133 modelRefresh->GetModelBufferPointer(reinterpret_cast<void **>(&modelObject));
134
135 if (modelObject)
136 {
137 return modelObject->snap_implementation->Refresh(modelRefresh);
138 }
139 else
140 {
141 HELPER_LOG_ERROR("The Model pointer returned from GetModelBufferPointer is not assigned");
142 return true;
143 }
144 }
145
WriteParameterizedModel(KIM::ModelWriteParameterizedModel const * const modelWriteParameterizedModel)146 int SNAP::WriteParameterizedModel(KIM::ModelWriteParameterizedModel const *const modelWriteParameterizedModel)
147 {
148 if (!modelWriteParameterizedModel)
149 {
150 HELPER_LOG_ERROR("The ModelWriteParameterizedModel pointer is not assigned");
151 return true;
152 }
153
154 SNAP *modelObject = NULL;
155
156 modelWriteParameterizedModel->GetModelBufferPointer(reinterpret_cast<void **>(&modelObject));
157
158 if (modelObject)
159 {
160 return modelObject->snap_implementation->WriteParameterizedModel(modelWriteParameterizedModel);
161 }
162 else
163 {
164 HELPER_LOG_ERROR("The Model pointer returned from GetModelBufferPointer is not assigned");
165 return true;
166 }
167 }
168
169 // static member function
Compute(KIM::ModelCompute const * const modelCompute,KIM::ModelComputeArguments const * const modelComputeArguments)170 int SNAP::Compute(KIM::ModelCompute const *const modelCompute,
171 KIM::ModelComputeArguments const *const modelComputeArguments)
172 {
173 if (!modelCompute || !modelComputeArguments)
174 {
175 if (!modelCompute)
176 {
177 HELPER_LOG_ERROR("The ModelCompute object pointer is not assigned");
178 }
179 if (!modelComputeArguments)
180 {
181 HELPER_LOG_ERROR("The ModelComputeArguments object pointer is not assigned");
182 }
183 return true;
184 }
185
186 SNAP *modelObject = NULL;
187
188 modelCompute->GetModelBufferPointer(reinterpret_cast<void **>(&modelObject));
189
190 if (modelObject)
191 {
192 return modelObject->snap_implementation->Compute(modelCompute, modelComputeArguments);
193 }
194 else
195 {
196 HELPER_LOG_ERROR("The Model pointer returned from GetModelBufferPointer is not assigned");
197 return true;
198 }
199 }
200
201 // static member function
ComputeArgumentsCreate(KIM::ModelCompute const * const modelCompute,KIM::ModelComputeArgumentsCreate * const modelComputeArgumentsCreate)202 int SNAP::ComputeArgumentsCreate(KIM::ModelCompute const *const modelCompute,
203 KIM::ModelComputeArgumentsCreate *const modelComputeArgumentsCreate)
204 {
205 if (!modelCompute || !modelComputeArgumentsCreate)
206 {
207 if (!modelCompute)
208 {
209 HELPER_LOG_ERROR("The ModelCompute object pointer is not assigned");
210 }
211 if (!modelComputeArgumentsCreate)
212 {
213 HELPER_LOG_ERROR("The ModelComputeArgumentsCreate object pointer is not assigned");
214 }
215 return true;
216 }
217
218 SNAP *modelObject = NULL;
219
220 modelCompute->GetModelBufferPointer(reinterpret_cast<void **>(&modelObject));
221
222 if (modelObject)
223 {
224 return modelObject->snap_implementation->ComputeArgumentsCreate(modelComputeArgumentsCreate);
225 }
226 else
227 {
228 HELPER_LOG_ERROR("The Model pointer returned from GetModelBufferPointer is not assigned");
229 return true;
230 }
231 }
232
233 // static member function
ComputeArgumentsDestroy(KIM::ModelCompute const * const modelCompute,KIM::ModelComputeArgumentsDestroy * const modelComputeArgumentsDestroy)234 int SNAP::ComputeArgumentsDestroy(KIM::ModelCompute const *const modelCompute,
235 KIM::ModelComputeArgumentsDestroy *const modelComputeArgumentsDestroy)
236 {
237 if (!modelCompute || !modelComputeArgumentsDestroy)
238 {
239 if (!modelCompute)
240 {
241 HELPER_LOG_ERROR("The ModelCompute object pointer is not assigned");
242 }
243 if (!modelComputeArgumentsDestroy)
244 {
245 HELPER_LOG_ERROR("The ModelComputeArgumentsDestroy object pointer is not assigned");
246 }
247 return true;
248 }
249
250 SNAP *modelObject = NULL;
251
252 modelCompute->GetModelBufferPointer(reinterpret_cast<void **>(&modelObject));
253
254 if (modelObject)
255 {
256 return modelObject->snap_implementation->ComputeArgumentsDestroy(modelComputeArgumentsDestroy);
257 }
258 else
259 {
260 HELPER_LOG_ERROR("The Model pointer returned from GetModelBufferPointer is not assigned");
261 return true;
262 }
263 }
264
265 #undef HELPER_LOG_ERROR
266