jobject vector_Ptr_Layer_to_List(JNIEnv* env, std::vector<cv::Ptr<cv::dnn::Layer> >& vs)
{
static jclass juArrayList = ARRAYLIST(env);
static jmethodID m_create = CONSTRUCTOR(env, juArrayList);
jmethodID m_add = LIST_ADD(env, juArrayList);
static jclass jLayerClass = LAYER(env);
static jmethodID m_create_layer = LAYER_CONSTRUCTOR(env, jLayerClass);
jobject result = env->NewObject(juArrayList, m_create, vs.size());
for (std::vector< cv::Ptr<cv::dnn::Layer> >::iterator it = vs.begin(); it != vs.end(); ++it) {
jobject element = env->NewObject(jLayerClass, m_create_layer, (*it).get());
env->CallBooleanMethod(result, m_add, element);
env->DeleteLocalRef(element);
}
return result;
}
std::vector<cv::Ptr<cv::dnn::Layer> > List_to_vector_Ptr_Layer(JNIEnv* env, jobject list)
{
static jclass juArrayList = ARRAYLIST(env);
jmethodID m_size = LIST_SIZE(env, juArrayList);
jmethodID m_get = LIST_GET(env, juArrayList);
static jclass jLayerClass = LAYER(env);
jint len = env->CallIntMethod(list, m_size);
std::vector< cv::Ptr<cv::dnn::Layer> > result;
result.reserve(len);
for (jint i=0; i<len; i++)
{
jobject element = static_cast<jobject>(env->CallObjectMethod(list, m_get, i));
cv::Ptr<cv::dnn::Layer>* layer_ptr = (cv::Ptr<cv::dnn::Layer>*) GETNATIVEOBJ(env, jLayerClass, element) ;
cv::Ptr<cv::dnn::Layer> layer = *(layer_ptr);
result.push_back(layer);
env->DeleteLocalRef(element);
}
return result;
}
std::vector<MatShape> List_to_vector_MatShape(JNIEnv* env, jobject list)
{
static jclass juArrayList = ARRAYLIST(env);
jmethodID m_size = LIST_SIZE(env, juArrayList);
jmethodID m_get = LIST_GET(env, juArrayList);
static jclass jMatOfInt = MATOFINT(env);
jint len = env->CallIntMethod(list, m_size);
std::vector<MatShape> result;
result.reserve(len);
for (jint i=0; i<len; i++)
{
jobject element = static_cast<jobject>(env->CallObjectMethod(list, m_get, i));
cv::Mat& mat = *((cv::Mat*) GETNATIVEOBJ(env, jMatOfInt, element) );
MatShape matshape = (MatShape) mat;
result.push_back(matshape);
env->DeleteLocalRef(element);
}
return result;
}
int main() {
// Floating point precision
typedef double FLOAT;
// Units
typedef angstrom<FLOAT> x; // length
typedef K<FLOAT> T; // temperature
typedef u<FLOAT> m; // mass
typedef angstrom_div_ps<FLOAT> v; // velocity
typedef angstrom_div_ps2<FLOAT> a; // acceleration
typedef u_mul_angstrom_div_ps2<FLOAT> f; // force
typedef u_mul_angstrom2_div_ps2<FLOAT> e; // energy
typedef ps<FLOAT> t; // time
// Declarations
auto mass = m(39.948);
auto temp = T(100);
auto epsilon = T(119.8);
auto dx = x(5.26);
auto sigma = x(3.405);
auto dt = t(0.01);
auto t_end = t(10);
auto N = ARRAYLIST(size_t, 4, 4, 4);
string molecule[4];
molecule[0] = "Ar";
molecule[1] = "Ar";
molecule[2] = "Ar";
molecule[3] = "Ar";
ofstream time_file;
time_file.open("time.dat");
auto t0 = clock();
// Boltzmann velocity dirstribution
Boltzmann<FLOAT> boltz(temp, mass);
Gaussian<v> gauss(boltz.StandardDeviation());
auto boltz_vel = delegate(gauss, &Gaussian<v>::Distribution_mu_0);
// Models
typedef VMD<x,Vector<v,3>> pos;
typedef VMD_Vel<x,v> vel;
typedef Vector<a,3> va;
typedef Array<va> acc;
typedef PBC<pos,vel,acc,void,x,3>::CX pref;
typedef PBC<pos,vel,acc,void,x,3>::CA aref;
typedef LJ_Potential<3,x,a,m,f,e> Potential;
typedef Delegate<void,pref&,aref&> LJ_Solver;
typedef PBC<pos,vel,acc,LJ_Solver,x,3> Boundary;
typedef Delegate<void,pos&> PeriodicBoundary;
typedef Delegate<void,pos&,vel&,acc&> List;
typedef VelocityVerlet<2,pos,vel,va,List> VerletModel;
typedef Delegate<void,t&> VerletSolver;
// Molecular dynamic model
MD_Model<m,t,x,v,VerletSolver,PeriodicBoundary> model(mass, dt, "Argon centered cubic lattice");
// Lennard-Jones potenial
Potential potential(sigma, mass, 0);
auto LJ_acc = delegate(potential, &Potential::Acceleration<pref,aref>);
// Periodic bounary condition
Boundary pbc(LJ_acc);
for(size_t i = 0; i < 3; i++) {
pbc.origin[i] = -0.25*dx;
pbc.range[i] = dx*(N[i]-0.25);
}
auto periodic_boundary = delegate(pbc, &Boundary::Boundary<pos>);
model.boundary = &periodic_boundary;
auto list = delegate(pbc, &Boundary::NeighbourList);
auto dist_vec = delegate(static_cast<MinImage<x,3>&>(pbc), &MinImage<x,3>::Distance<x,x>);
auto dist = delegate(&Euclidean::Length<Vector<x,3>>);
auto unit_vec = delegate(&Euclidean::UnitVector<x,x,3>);
potential.dist_vec = &dist_vec;
potential.dist = &dist;
potential.unit_vec = &unit_vec;
// Verlet differential solver
VerletModel verlet(static_cast<pos&>(model), static_cast<vel&>(model), list);
auto verlet_solver = delegate(verlet, &VerletModel::Solve<t>);
model.step = &verlet_solver;
// Lattice configuration
model.LatticeCenteredCubic(molecule, dx, N);
model.SetVelocityDistribution(boltz_vel);
auto data = static_cast<vel>(model);
TimeStep<t,decltype(model)> time(model);
// Task a and b
/*time.Open("b.xyz");
time.Print();
time.Close();*/
// Task c
auto step = delegate(model, &decltype(model)::Step<t,decltype(model)>);
auto Time = time;
/*Time.Open("c.xyz");
Run(Time, t_end, step);
Time.Close();*/
// Task d
auto boundary = delegate(model, &decltype(model)::Boundary<t,decltype(model)>);
/**time.data = data;
Time = time;
Time.Open("d.xyz");
Run(Time, t_end, step, boundary);
Time.Close();*/
// Task g
potential = epsilon * Boltzmann<FLOAT>::kB;
/**time.data = data;
Time = time;
Time.Open("g.xyz");
verlet = 0; // Initialize verlet solver
t0 = clock();
Run(Time, t_end, step, boundary);
time_file << (double)(clock()-t0)/CLOCKS_PER_SEC << " & ";
Time.Close();*/
// Task h
for(size_t i = 0; i < 3; i++)
pbc[i] = (pbc.range[i]-pbc.origin[i])/(3*sigma);
*time.data = data;
Time = time;
Time.Open("h.xyz");
verlet = 0; // Initialize verlet solver
t0 = clock();
Run(Time, t_end, step, boundary);
time_file << (double)(clock()-t0)/CLOCKS_PER_SEC << " \\\\ ";
Time.Close();
time_file.close();
return 0;
}
