/***********************************************************************//** * @brief Load cube into the model class * * @param[in] filename cube file. * * @exception GException::invalid_value * Number of maps in cube mismatches number of energy bins. * * Loads cube into the model class. ***************************************************************************/ void GModelSpatialDiffuseCube::load(const std::string& filename) { // Initialise skymap m_cube.clear(); m_logE.clear(); // Store filename of cube (for XML writing). Note that we do not // expand any environment variable at this level, so that if we write // back the XML element we write the filepath with the environment // variables m_filename = filename; // Get expanded filename std::string fname = gammalib::expand_env(filename); // Load cube m_cube.load(fname); // Load energies GEnergies energies(fname); // Extract number of energy bins int num = energies.size(); // Check if energy binning is consistent with primary image hdu if (num != m_cube.nmaps() ) { std::string msg = "Number of energies in \"ENERGIES\" extension" " ("+gammalib::str(num)+") does not match the" " number of maps ("+gammalib::str(m_cube.nmaps())+"" " in the map cube.\n" "The \"ENERGIES\" extension table shall provide" " one enegy value for each map in the cube."; throw GException::invalid_value(G_LOAD, msg); } // Set log10(energy) nodes, where energy is in units of MeV for (int i = 0; i < num; ++i) { m_logE.append(energies[i].log10MeV()); } // Signal that cube has been loaded m_loaded = true; // Set energy boundaries set_energy_boundaries(); // Update Monte Carlo cache update_mc_cache(); // Return return; }
vec Solver::CCD_ReturnAllIterations(){ // Variation of CCD() made to store correlation energy for every iteration vec energies = zeros<vec>(0); double E0 = CorrolationEnergy(); UpdateAmplitudes(); double E1 = CorrolationEnergy(); NIterations = 0; tolerance = 1e-12; energies.insert_rows(NIterations,1); energies(NIterations) = E1; NIterations++; while ( AbsoluteDifference(E1,E0) > tolerance && NIterations < 50){ E0 = E1; UpdateAmplitudes(); E1 = CorrolationEnergy(); energies.insert_rows(NIterations,1); energies(NIterations) = E1; NIterations ++; } return energies; }
//TODO: add timer void run(int size, double coupling, IsingModel<dimensions>::Algorithms algo, int sweeps){ QElapsedTimer timer; timer.start(); QVector<int> energies(nModels); QVector<int> absoluteMagnetism(nModels); QFile file(QString("./%3d_%0_%1_%2.dat").arg(size).arg(coupling).arg(algo).arg(dimensions)); if (!file.open(QIODevice::WriteOnly | QIODevice::Text)){ std::cout << "Couldn't open file " << file.fileName().toStdString() << std::endl; return; } QTextStream out(&file); std::cout << "Starting with " << file.fileName().toStdString() << std::endl; IsingModel<dimensions> ising[nModels]; QVector<double> magnetization, magnetizationVariance; QVector<double> energy, energyVariance; for(int k = 0; k < nModels; k++){ ising[k].setSize(size); ising[k].setAlgorithm(algo); ising[k].setCoupling(coupling); } out << dimensions << " " << size << " " << coupling << " " << nModels << "\n\n"; out << ising[0].getMagnetization() << " " << sqrt(0) << " " << ising[0].getEnergy() << " " << sqrt(0) << "\n"; for(int i = 0; i < sweeps;i++){ for(int k = 0; k < nModels;k++){ ising[k].sweep(); absoluteMagnetism[k] = abs(ising[k].getMagnetization()); energies[k] = ising[k].getEnergy(); } double magneticMean = calculateMean(absoluteMagnetism); magnetization.append(magneticMean); magnetizationVariance.append(calculateVariance(absoluteMagnetism, magneticMean)); double energyMean = calculateMean(energies); energy.append(energyMean); energyVariance.append(calculateVariance(energies, energyMean)); } for(int i = 0; i < magnetization.size();i++) out << magnetization[i] << " " << magnetizationVariance[i] << " " << energy[i] << " " << energyVariance[i] << "\n"; std::cout << "Finished with " << file.fileName().toStdString() << " in " << timer.elapsed() << "ms" << std::endl; }
int main(int argc, char *argv[]) { /* Welcome */ welcome(); test(); /* Do step 0, initialization */ db_open(); printf("Step 0. Initialize enviroment\n"); fflush(stdout); if (init()) { db_close(); printf("Help message: double check file \"run.prm\" in current directory.\n"); return USERERR; } else printf("Step 0 Done.\n\n"); /* Do step 1, premcce */ if (env.do_premcce) { printf("Step 1. Test and format structral file\n"); fflush(stdout); if (premcce()) {db_close(); return USERERR;} else printf("Step 1 Done.\n\n"); } else printf("Not doing \"Step 1. Test and format structral file\"\n\n"); /* Do step 2. rotamers */ if (env.do_rotamers) { printf("Step 2. Make multi side chain conformers\n"); fflush(stdout); if (env.sidechain_opt==1) {//genetic algorithm sidechain packing optimization printf("***Using Pascal Comte's (Brock University-Computer Science,2010) [Paper Ref.: ] Sidechain Packing GA & Bi-directional Evolutionary Sampling***\n"); // rotamers_GA(argc,argv); } else if (rotamers()) { db_close(); return USERERR; } else printf("Step 2 Done.\n\n"); } else printf("Not doing \"Step 2. Make multi side chain conformers\"\n\n"); /* Do step 3. energies */ if (env.do_energies) { printf("Step 3. Compute energy lookup table\n"); fflush(stdout); if (energies()) {db_close(); return USERERR;} else printf("Step 3 Done.\n\n"); } else printf("Not doing \"Step 3. Compute energy lookup table\"\n\n"); /* Do step 4. Monte Carlo */ if (env.do_monte) { printf("Step 4. Monte Carlo Sampling\n"); fflush(stdout); if (!env.monte_adv_opt) { if (monte()) {db_close(); return USERERR;} else printf("Step 4 Done.\n\n"); } else { if (monte2()) {db_close(); return USERERR;} else printf("Step 4 Done.\n\n"); } } else printf("Not doing \"Step 4. Monte Carlo Sampling\"\n\n"); db_close(); return 0; }
void cmaxent_fortran( double* xqmc, double* xtau, int32_t len, double xmom1, double ( *xker ) ( const double&, double&, double& ), double ( *backtrans ) ( double&, double&, double& ), double beta, double* alpha_tot, int32_t n_alpha, int32_t ngamma, double omega_start, double omega_end, int32_t omega_points, int32_t nsweeps, int32_t nbins, int32_t nwarmup,/* double* u,*/ double* sigma) { std::string fr("Aom"); std::string dA("dump_Aom"); std::string ml("max_stoch_log"); std::string energies("energies"); std::string bf("best_fit"); std::string dump("dump"); cmaxent(xqmc, xtau, len, xmom1, xker, backtrans, beta, alpha_tot, n_alpha, ngamma, omega_start, omega_end, omega_points, nsweeps, nbins, nwarmup, fr, dA, ml, energies, bf, dump, /*u*/NULL, sigma); }
void CompleteExtendedHogFilter::buildDescriptors(Mat& descriptors, size_t cellRowCount, size_t cellColumnCount, size_t descriptorSize) const { size_t binHalfCount = binCount / 2; // compute gradient energy of cells Mat energies(descriptors.rows, descriptors.cols, CV_32FC1); if (signedGradients) { // gradient energy should be computed over unsigned gradients, so the signed parts have to be added up for (size_t rowIndex = 0; rowIndex < cellRowCount; ++rowIndex) { for (size_t colIndex = 0; colIndex < cellColumnCount; ++colIndex) { float energy = 0; float* histogramValues = descriptors.ptr<float>(rowIndex, colIndex); for (size_t binIndex = 0; binIndex < binHalfCount; ++binIndex) { float unsignedBinValue = histogramValues[binIndex] + histogramValues[binIndex + binHalfCount]; energy += unsignedBinValue * unsignedBinValue; } energies.at<float>(rowIndex, colIndex) = energy; } } } else { for (size_t rowIndex = 0; rowIndex < cellRowCount; ++rowIndex) { for (size_t colIndex = 0; colIndex < cellColumnCount; ++colIndex) { float energy = 0; float* histogramValues = descriptors.ptr<float>(rowIndex, colIndex); for (size_t binIndex = 0; binIndex < binCount; ++binIndex) energy += histogramValues[binIndex] * histogramValues[binIndex]; energies.at<float>(rowIndex, colIndex) = energy; } } } // build normalized cell descriptors if (signedGradients && unsignedGradients) { // signed and unsigned gradients should be combined into descriptor for (size_t rowIndex = 0; rowIndex < cellRowCount; ++rowIndex) { for (size_t colIndex = 0; colIndex < cellColumnCount; ++colIndex) { float* descriptor = descriptors.ptr<float>(rowIndex, colIndex); int r1 = rowIndex; int r0 = std::max(0, static_cast<int>(rowIndex) - 1); int r2 = std::min(rowIndex + 1, cellRowCount - 1); int c1 = colIndex; int c0 = std::max(0, static_cast<int>(colIndex) - 1); int c2 = std::min(colIndex + 1, cellColumnCount - 1); float sqn00 = energies.at<float>(r0, c0); float sqn01 = energies.at<float>(r0, c1); float sqn02 = energies.at<float>(r0, c2); float sqn10 = energies.at<float>(r1, c0); float sqn11 = energies.at<float>(r1, c1); float sqn12 = energies.at<float>(r1, c2); float sqn20 = energies.at<float>(r2, c0); float sqn21 = energies.at<float>(r2, c1); float sqn22 = energies.at<float>(r2, c2); float n1 = 1.f / sqrt(sqn00 + sqn01 + sqn10 + sqn11 + eps); float n2 = 1.f / sqrt(sqn01 + sqn02 + sqn11 + sqn12 + eps); float n3 = 1.f / sqrt(sqn10 + sqn11 + sqn20 + sqn21 + eps); float n4 = 1.f / sqrt(sqn11 + sqn12 + sqn21 + sqn22 + eps); // unsigned orientation features (aka contrast-insensitive) for (size_t binIndex = 0; binIndex < binHalfCount; ++binIndex) { float sum = descriptor[binIndex] + descriptor[binIndex + binHalfCount]; float h1 = std::min(alpha, sum * n1); float h2 = std::min(alpha, sum * n2); float h3 = std::min(alpha, sum * n3); float h4 = std::min(alpha, sum * n4); descriptor[binCount + binIndex] = 0.5 * (h1 + h2 + h3 + h4); } float t1 = 0; float t2 = 0; float t3 = 0; float t4 = 0; // signed orientation features (aka contrast-sensitive) for (size_t binIndex = 0; binIndex < binCount; ++binIndex) { float h1 = std::min(alpha, descriptor[binIndex] * n1); float h2 = std::min(alpha, descriptor[binIndex] * n2); float h3 = std::min(alpha, descriptor[binIndex] * n3); float h4 = std::min(alpha, descriptor[binIndex] * n4); descriptor[binIndex] = 0.5 * (h1 + h2 + h3 + h4); t1 += h1; t2 += h2; t3 += h3; t4 += h4; } // energy features descriptor[binCount + binHalfCount] = 0.2357 * t1; descriptor[binCount + binHalfCount + 1] = 0.2357 * t2; descriptor[binCount + binHalfCount + 2] = 0.2357 * t3; descriptor[binCount + binHalfCount + 3] = 0.2357 * t4; } } } else { // only signed or unsigned gradients should be in descriptor for (size_t rowIndex = 0; rowIndex < cellRowCount; ++rowIndex) { for (size_t colIndex = 0; colIndex < cellColumnCount; ++colIndex) { float* descriptor = descriptors.ptr<float>(rowIndex, colIndex); int r1 = rowIndex; int r0 = std::max(0, static_cast<int>(rowIndex) - 1); int r2 = std::min(rowIndex + 1, cellRowCount - 1); int c1 = colIndex; int c0 = std::max(0, static_cast<int>(colIndex) - 1); int c2 = std::min(colIndex + 1, cellColumnCount - 1); float sqn00 = energies.at<float>(r0, c0); float sqn01 = energies.at<float>(r0, c1); float sqn02 = energies.at<float>(r0, c2); float sqn10 = energies.at<float>(r1, c0); float sqn11 = energies.at<float>(r1, c1); float sqn12 = energies.at<float>(r1, c2); float sqn20 = energies.at<float>(r2, c0); float sqn21 = energies.at<float>(r2, c1); float sqn22 = energies.at<float>(r2, c2); float n1 = 1.f / sqrt(sqn00 + sqn01 + sqn10 + sqn11 + eps); float n2 = 1.f / sqrt(sqn01 + sqn02 + sqn11 + sqn12 + eps); float n3 = 1.f / sqrt(sqn10 + sqn11 + sqn20 + sqn21 + eps); float n4 = 1.f / sqrt(sqn11 + sqn12 + sqn21 + sqn22 + eps); float t1 = 0; float t2 = 0; float t3 = 0; float t4 = 0; // orientation features for (size_t binIndex = 0; binIndex < binCount; ++binIndex) { float h1 = std::min(alpha, descriptor[binIndex] * n1); float h2 = std::min(alpha, descriptor[binIndex] * n2); float h3 = std::min(alpha, descriptor[binIndex] * n3); float h4 = std::min(alpha, descriptor[binIndex] * n4); descriptor[binIndex] = 0.5 * (h1 + h2 + h3 + h4); t1 += h1; t2 += h2; t3 += h3; t4 += h4; } // energy features descriptor[binCount] = 0.2357 * t1; descriptor[binCount + 1] = 0.2357 * t2; descriptor[binCount + 2] = 0.2357 * t3; descriptor[binCount + 3] = 0.2357 * t4; } } } }
/** * mbsolve-tool main function. * \ingroup MBSOLVE_TOOL * * Specify the simulation setup using the -d parameter (The available setups * are described below.) and the solver method using the -m parameter * (Currently, the only option available is openmp-Xlvl-os-red. Replace X * with the number of levels.) For the complete list of parameters, run * mbsolve-tool -h. */ int main(int argc, char **argv) { /* parse command line arguments */ parse_args(argc, argv); try { ti::cpu_timer timer; double total_time = 0; std::shared_ptr<mbsolve::device> dev; std::shared_ptr<mbsolve::scenario> scen; if (device_file == "song2005") { /** * The song2005 setup features a three-level active region which * is excited by a sech pulse. For details see literature: * Song X. et al., Propagation of a Few-Cycle Laser Pulse * in a V-Type Three-Level System, Optics and Spectroscopy, * Vol. 99, No. 4, 2005, pp. 517–521 * https://doi.org/10.1134/1.2113361 */ /* set up quantum mechanical description */ std::vector<mbsolve::real> energies = { 0, 2.3717 * mbsolve::HBAR * 1e15, 2.4165 * mbsolve::HBAR * 1e15 }; mbsolve::qm_operator H(energies); std::vector<mbsolve::complex> dipoles = { mbsolve::E0 * 9.2374e-11, mbsolve::E0 * 9.2374e-11 * sqrt(2), 0 }; mbsolve::qm_operator u({0, 0, 0}, dipoles); mbsolve::real rate = 1e10; std::vector<std::vector<mbsolve::real> > scattering_rates = { { 0, rate, rate }, { rate, 0, rate }, { rate, rate, 0 } }; auto relax_sop = std::make_shared<mbsolve::qm_lindblad_relaxation> (scattering_rates); auto qm = std::make_shared<mbsolve::qm_description> (6e24, H, u, relax_sop); auto mat_vac = std::make_shared<mbsolve::material>("Vacuum"); mbsolve::material::add_to_library(mat_vac); auto mat_ar = std::make_shared<mbsolve::material>("AR_Song", qm); mbsolve::material::add_to_library(mat_ar); dev = std::make_shared<mbsolve::device>("Song"); dev->add_region(std::make_shared<mbsolve::region> ("Active region", mat_ar, 0, 150e-6)); /* default settings */ if (num_gridpoints == 0) { num_gridpoints = 32768; } if (sim_endtime < 1e-21) { sim_endtime = 80e-15; } mbsolve::qm_operator rho_init({1, 0, 0}); /* Song basic scenario */ scen = std::make_shared<mbsolve::scenario> ("Basic", num_gridpoints, sim_endtime, rho_init); auto sech_pulse = std::make_shared<mbsolve::sech_pulse> ("sech", 0.0, mbsolve::source::hard_source, 3.5471e9, 3.8118e14, 17.248, 1.76/5e-15, -M_PI/2); scen->add_source(sech_pulse); scen->add_record(std::make_shared<mbsolve::record> ("d11", mbsolve::record::type::density, 1, 1, 0, 0)); scen->add_record(std::make_shared<mbsolve::record> ("d22", mbsolve::record::type::density, 2, 2, 0, 0)); scen->add_record(std::make_shared<mbsolve::record> ("d33", mbsolve::record::type::density, 3, 3, 0, 0)); scen->add_record(std::make_shared<mbsolve::record>("e", 0, 0.0)); } else if (device_file == "ziolkowski1995") { /** * The ziolkowski1995 setup is a self induced transparency (SIT) * setup that consists of a two-level active region embedded in * two vacuum section. For details see literature: * https://doi.org/10.1103/PhysRevA.52.3082 */ /* set up quantum mechanical description */ auto qm = std::make_shared<mbsolve::qm_desc_2lvl> (1e24, 2 * M_PI * 2e14, 6.24e-11, 1.0e10, 1.0e10); /* materials */ auto mat_vac = std::make_shared<mbsolve::material>("Vacuum"); auto mat_ar = std::make_shared<mbsolve::material> ("AR_Ziolkowski", qm); mbsolve::material::add_to_library(mat_vac); mbsolve::material::add_to_library(mat_ar); /* set up device */ dev = std::make_shared<mbsolve::device>("Ziolkowski"); dev->add_region(std::make_shared<mbsolve::region> ("Vacuum left", mat_vac, 0, 7.5e-6)); dev->add_region(std::make_shared<mbsolve::region> ("Active region", mat_ar, 7.5e-6, 142.5e-6)); dev->add_region(std::make_shared<mbsolve::region> ("Vacuum right", mat_vac, 142.5e-6, 150e-6)); /* default settings */ if (num_gridpoints == 0) { num_gridpoints = 32768; } if (sim_endtime < 1e-21) { sim_endtime = 200e-15; } mbsolve::qm_operator rho_init({1, 0, 0}); /* Ziolkowski basic scenario */ scen = std::make_shared<mbsolve::scenario> ("Basic", num_gridpoints, sim_endtime, rho_init); auto sech_pulse = std::make_shared<mbsolve::sech_pulse> //("sech", 0.0, mbsolve::source::hard_source, 4.2186e9/2, 2e14, ("sech", 0.0, mbsolve::source::hard_source, 4.2186e9, 2e14, 10, 2e14); scen->add_source(sech_pulse); scen->add_record(std::make_shared<mbsolve::record> ("inv12", 2.5e-15)); scen->add_record(std::make_shared<mbsolve::record>("e", 2.5e-15)); } else if (device_file == "tzenov2018-cpml") { /** * The tzenov2018-cpml setup consists of an absorber region * embedded in two gain regions. Each region is modeled as a * two-level system. The results show that short pulses are * generated due to colliding pulse mode-locking (CPML). * For details see literature: * https://doi.org/10.1088/1367-2630/aac12a */ /* set up quantum mechanical descriptions */ auto qm_gain = std::make_shared<mbsolve::qm_desc_2lvl> (5e21, 2 * M_PI * 3.4e12, 2e-9, 1.0/10e-12, 1.0/200e-15, 1.0); auto qm_absorber = std::make_shared<mbsolve::qm_desc_2lvl> (1e21, 2 * M_PI * 3.4e12, 6e-9, 1.0/3e-12, 1.0/160e-15); /* materials */ auto mat_absorber = std::make_shared<mbsolve::material> ("Absorber", qm_absorber, 12.96, 1.0, 500); auto mat_gain = std::make_shared<mbsolve::material> ("Gain", qm_gain, 12.96, 1.0, 500); mbsolve::material::add_to_library(mat_absorber); mbsolve::material::add_to_library(mat_gain); /* set up device */ dev = std::make_shared<mbsolve::device>("tzenov-cpml"); dev->add_region(std::make_shared<mbsolve::region> ("Gain R", mat_gain, 0, 0.5e-3)); dev->add_region(std::make_shared<mbsolve::region> ("Absorber", mat_absorber, 0.5e-3, 0.625e-3)); dev->add_region(std::make_shared<mbsolve::region> ("Gain L", mat_gain, 0.625e-3, 1.125e-3)); /* default settings */ if (num_gridpoints == 0) { num_gridpoints = 8192; } if (sim_endtime < 1e-21) { sim_endtime = 2e-9; } mbsolve::qm_operator rho_init({0.5, 0.5}, {0.001}); /* basic scenario */ scen = std::make_shared<mbsolve::scenario> ("basic", num_gridpoints, sim_endtime, rho_init); scen->add_record(std::make_shared<mbsolve::record> ("inv12", 1e-12)); scen->add_record(std::make_shared<mbsolve::record>("e", 1e-12)); scen->add_record(std::make_shared<mbsolve::record> ("e0", mbsolve::record::electric, 1, 1, 0.0, 0.0)); scen->add_record(std::make_shared<mbsolve::record> ("h0", mbsolve::record::magnetic, 1, 1, 0.0, 1.373e-7)); } else if (device_file == "marskar2011") { /** * The marskar2011 setup is a 6-level anharmonic ladder system. * In the scenario, the interaction with a few-cycle Gaussian pulse * is simulated. For details see literature: * https://doi.org/10.1364/OE.19.016784 */ /* set up quantum mechanical description */ std::vector<mbsolve::real> energies(6, 0.0); for (int i = 1; i < 6; i++) { energies[i] = energies[i - 1] + (1.0 - 0.1 * (i - 3)) * mbsolve::HBAR * 2 * M_PI * 1e13; } mbsolve::qm_operator H(energies); mbsolve::real dipole = 1e-29; std::vector<mbsolve::complex> dipoles = { dipole, 0, dipole, 0, 0, dipole, 0, 0, 0, dipole, 0, 0, 0, 0, dipole }; mbsolve::qm_operator u({0, 0, 0, 0, 0, 0}, dipoles); mbsolve::real rate = 1e12; std::vector<std::vector<mbsolve::real> > scattering_rates = { { rate, 1.0/(1.0e-12), 0, 0, 0, 0 }, { 3.82950e+11, rate, 1.0/(1.1e-12), 0, 0, 0 }, { 0, 3.77127e+11, rate, 1.0/(1.2e-12), 0, 0 }, { 0, 0, 3.74488e+11, rate, 1.0/(1.3e-12), 0 }, { 0, 0, 0, 3.74467e+11, rate, 1.0/(1.4e-12) }, { 0, 0, 0, 0, 3.76675e+11, rate } }; auto relax_sop = std::make_shared<mbsolve::qm_lindblad_relaxation> (scattering_rates); auto qm = std::make_shared<mbsolve::qm_description> (1e25, H, u, relax_sop); /* materials */ auto mat_vac = std::make_shared<mbsolve::material>("Vacuum"); mbsolve::material::add_to_library(mat_vac); auto mat_ar = std::make_shared<mbsolve::material>("AR_Marsk", qm); mbsolve::material::add_to_library(mat_ar); /* set up device */ dev = std::make_shared<mbsolve::device>("Marskar"); dev->add_region(std::make_shared<mbsolve::region> ("Active region", mat_ar, 0, 1e-3)); /* default settings */ if (num_gridpoints == 0) { num_gridpoints = 8192; } if (sim_endtime < 1e-21) { sim_endtime = 2e-12; } mbsolve::qm_operator rho_init({0.60, 0.23, 0.096, 0.044, 0.02, 0.01}); /* Marskar basic scenario */ scen = std::make_shared<mbsolve::scenario> ("Basic", num_gridpoints, sim_endtime, rho_init); /* input pulse */ mbsolve::real tau = 100e-15; auto pulse = std::make_shared<mbsolve::gaussian_pulse> ("gaussian", 0.0, /* position */ mbsolve::source::hard_source, 5e8, /* amplitude */ 1e13, /* frequency */ 3.0 * tau, /* phase: 3*tau */ tau /* tau */ ); scen->add_source(pulse); /* select data to be recorded */ mbsolve::real sample_time = 0.0; mbsolve::real sample_pos = 0.0; scen->add_record(std::make_shared<mbsolve::record> ("d11", mbsolve::record::type::density, 1, 1, sample_time, sample_pos)); scen->add_record(std::make_shared<mbsolve::record> ("d22", mbsolve::record::type::density, 2, 2, sample_time, sample_pos)); scen->add_record(std::make_shared<mbsolve::record> ("d33", mbsolve::record::type::density, 3, 3, sample_time, sample_pos)); scen->add_record(std::make_shared<mbsolve::record> ("d44", mbsolve::record::type::density, 4, 4, sample_time, sample_pos)); scen->add_record(std::make_shared<mbsolve::record> ("d55", mbsolve::record::type::density, 5, 5, sample_time, sample_pos)); scen->add_record(std::make_shared<mbsolve::record> ("d66", mbsolve::record::type::density, 6, 6, sample_time, sample_pos)); scen->add_record(std::make_shared<mbsolve::record> ("e", mbsolve::record::type::electric, 0, 0, sample_time, sample_pos)); } else { throw std::invalid_argument("Specified device not found!"); } /* tic */ timer.start(); mbsolve::writer writer(writer_method); mbsolve::solver solver(solver_method, dev, scen); /* toc */ timer.stop(); ti::cpu_times times = timer.elapsed(); std::cout << "Time required (setup): " << 1e-9 * times.wall << std::endl; total_time +=1e-9 * times.wall; std::cout << solver.get_name() << std::endl; /* tic */ timer.start(); /* execute solver */ solver.run(); /* toc */ timer.stop(); times = timer.elapsed(); std::cout << "Time required (run): " << 1e-9 * times.wall << std::endl; total_time +=1e-9 * times.wall; /* grid point updates per second */ double gpups = 1e-6 * 1e9/times.wall * scen->get_num_gridpoints() * scen->get_endtime()/scen->get_timestep_size(); std::cout << "Performance: " << gpups << " MGPU/s" << std::endl; /* tic */ timer.start(); /* write results */ writer.write(output_file, solver.get_results(), dev, scen); /* toc */ timer.stop(); times = timer.elapsed(); std::cout << "Time required (write): " << 1e-9 * times.wall << std::endl; total_time +=1e-9 * times.wall; std::cout << "Time required (total): " << total_time << std::endl; } catch (std::exception& e) { std::cout << "Error: " << e.what() << std::endl; exit(1); } exit(0); }