TEUCHOS_UNIT_TEST_TEMPLATE_3_DECL(
Kokkos_View_Fad, ScalarAssign, FadType, Layout, Device )
{
typedef typename ApplyView<FadType*,Layout,Device>::type ViewType;
typedef typename ViewType::size_type size_type;
typedef typename ViewType::HostMirror host_view_type;
typedef typename FadType::value_type value_type;
const size_type num_rows = global_num_rows;
const size_type fad_size = global_fad_size;
// Create and fill view
ViewType v("view", num_rows, fad_size+1);
typename ViewType::array_type va = v;
Kokkos::deep_copy( va, 1.0 );
// Deep copy a constant scalar
value_type a = 2.3456;
ScalarAssignKernel<ViewType,value_type>::apply( v, a );
// Copy to host
host_view_type hv = Kokkos::create_mirror_view(v);
Kokkos::deep_copy(hv, v);
// Check
success = true;
for (size_type i=0; i<num_rows; ++i) {
#if defined(HAVE_SACADO_VIEW_SPEC) && !defined(SACADO_DISABLE_FAD_VIEW_SPEC)
FadType f = FadType(fad_size, a);
#else
FadType f = a;
#endif
success = success && checkFads(f, hv(i), out);
}
}
QuadraticFunction3d ::
QuadraticFunction3d (const Point3d & p, const Vec3d & v)
{
Vec3d hv(v);
hv /= (hv.Length() + 1e-12);
Vec3d t1, t2;
hv.GetNormal (t1);
Cross (hv, t1, t2);
double t1p = t1.X() * p.X() + t1.Y() * p.Y() + t1.Z() * p.Z();
double t2p = t2.X() * p.X() + t2.Y() * p.Y() + t2.Z() * p.Z();
c0 = sqr (t1p) + sqr (t2p);
cx = -2 * (t1p * t1.X() + t2p * t2.X());
cy = -2 * (t1p * t1.Y() + t2p * t2.Y());
cz = -2 * (t1p * t1.Z() + t2p * t2.Z());
cxx = t1.X() * t1.X() + t2.X() * t2.X();
cyy = t1.Y() * t1.Y() + t2.Y() * t2.Y();
czz = t1.Z() * t1.Z() + t2.Z() * t2.Z();
cxy = 2 * t1.X() * t1.Y() + 2 * t2.X() * t2.Y();
cxz = 2 * t1.X() * t1.Z() + 2 * t2.X() * t2.Z();
cyz = 2 * t1.Y() * t1.Z() + 2 * t2.Y() * t2.Z();
/*
(*testout) << "c0 = " << c0
<< " clin = " << cx << " " << cy << " " << cz
<< " cq = " << cxx << " " << cyy << " " << czz
<< cxy << " " << cyz << " " << cyz << endl;
*/
}
TEUCHOS_UNIT_TEST_TEMPLATE_3_DECL(
Kokkos_View_Fad, DeepCopy_ConstantFadFull, FadType, Layout, Device )
{
typedef typename ApplyView<FadType**,Layout,Device>::type ViewType;
typedef typename ViewType::size_type size_type;
typedef typename ViewType::HostMirror host_view_type;
const size_type num_rows = global_num_rows;
const size_type num_cols = global_num_cols;
const size_type fad_size = global_fad_size;
// Create and fill view
ViewType v("view", num_rows, num_cols, fad_size+1);
typename ViewType::array_type va = v;
Kokkos::deep_copy( va, 1.0 );
// Deep copy a constant Fad
FadType a(fad_size, 2.3456);
for (size_type i=0; i<fad_size; ++i)
a.fastAccessDx(i) = 7.89 + (i+1);
Kokkos::deep_copy( v, a );
// Copy to host
host_view_type hv = Kokkos::create_mirror_view(v);
Kokkos::deep_copy(hv, v);
// Check
success = true;
for (size_type i=0; i<num_rows; ++i) {
for (size_type j=0; j<num_cols; ++j) {
success = success && checkFads(a, hv(i,j), out);
}
}
}
WPointF WCartesianChart::mapToDevice(const boost::any& xValue,
const boost::any& yValue,
Axis ordinateAxis, int xSegment,
int ySegment) const
{
const WAxis& xAxis = axis(XAxis);
const WAxis& yAxis = axis(ordinateAxis);
return hv(xAxis.mapToDevice(xValue, xSegment),
yAxis.mapToDevice(yValue, ySegment),
width().toPixels());
}
FTYPE max_flow(int s, int t) {
vector<int> ptr(g.V, 0), h(g.V, 0), nxt(g.V, -1), hv(2*g.V, -1);
vector<FTYPE> e(g.V, 0);
h[s] = g.V;
for (int i: g.adj[s]) {
int w = g.edges[i].v;
if (!g.edges[i].cap) continue;
if (!e[w] && w != t) {
nxt[w] = hv[0];
hv[0] = w;
}
e[w] += g.edges[i].cap;
e[s] -= g.edges[i].cap;
g.edges[i^1].cap = g.edges[i].cap;
g.edges[i].cap = 0;
}
int cur_h = 0;
while (cur_h >= 0) {
for (int v = hv[cur_h]; v != -1; v = nxt[v]) {
for (int &p = ptr[v]; p < (int)g.adj[v].size(); p++) {
int i = g.adj[v][p];
int w = g.edges[i].v;
if (h[w] < h[v] && g.edges[i].cap) {
FTYPE f = min(g.edges[i].cap, e[v]);
g.edges[i].cap -= f;
g.edges[i^1].cap += f;
if (!e[w] && w != t) {
nxt[w] = hv[h[w]];
hv[h[w]] = w;
}
e[w] += f;
e[v] -= f;
if (e[v] == 0) break;
}
}
hv[cur_h] = nxt[v];
if (e[v]) {
ptr[v] = 0;
h[v]++;
nxt[v] = hv[h[v]];
hv[h[v]] = v;
cur_h++;
break;
}
}
if (hv[cur_h] == -1) cur_h--;
}
return e[t];
}
void WingedEdgeBuilder::transformVertices(const real *vertices, unsigned vsize, const Matrix44r& transform, real *res)
{
const real *v = vertices;
real *pv = res;
for (unsigned int i = 0; i < vsize / 3; i++) {
HVec3r hv_tmp(v[0], v[1], v[2]);
HVec3r hv(transform * hv_tmp);
for (unsigned int j = 0; j < 3; j++)
pv[j] = hv[j] / hv[3];
v += 3;
pv += 3;
}
}
Kokkos::View<const T*,D>
getKokkosViewDeepCopy(const Teuchos::ArrayView<const T>& a) {
#if defined(KOKKOS_HAVE_PTHREAD)
typedef Kokkos::Threads HostDevice;
#elif defined(KOKKOS_HAVE_OPENMP)
typedef Kokkos::OpenMP HostDevice;
#else
typedef Kokkos::Serial HostDevice;
#endif
typedef Kokkos::View<T*,D> view_type;
typedef Kokkos::View<const T*,typename view_type::array_layout,HostDevice,Kokkos::MemoryUnmanaged> unmanaged_host_view_type;
if (a.size() == 0)
return view_type();
view_type v("", a.size());
unmanaged_host_view_type hv(a.getRawPtr(), a.size());
Kokkos::deep_copy(v,hv);
return v;
}
Kokkos::View<const T*,D>
getKokkosViewDeepCopy(const Teuchos::ArrayView<const T>& a)
{
typedef typename Kokkos::Impl::if_c<
Impl::VerifyExecutionCanAccessMemorySpace< D, Kokkos::HostSpace>::value,
typename D::execution_space, Kokkos::HostSpace>::type
HostDevice;
typedef Kokkos::View<T*, D> view_type;
typedef Kokkos::View<const T*, typename view_type::array_layout, HostDevice,
Kokkos::MemoryUnmanaged> unmanaged_host_view_type;
if (a.size () == 0) {
return view_type ();
}
view_type v ("", a.size ());
unmanaged_host_view_type hv (a.getRawPtr (), a.size ());
Kokkos::deep_copy (v, hv);
return v;
}
void T_CalcInverse (FlatMatrix<T2> inv)
{
// static Timer t("CalcInverse");
// RegionTimer reg(t);
// Gauss - Jordan - algorithm
// Algorithm of Stoer, Einf. i. d. Num. Math, S 145
// int n = m.Height();
int n = inv.Height();
ngstd::ArrayMem<int,100> p(n); // pivot-permutation
for (int j = 0; j < n; j++) p[j] = j;
for (int j = 0; j < n; j++)
{
// pivot search
double maxval = abs(inv(j,j));
int r = j;
for (int i = j+1; i < n; i++)
if (abs (inv(j, i)) > maxval)
{
r = i;
maxval = abs (inv(j, i));
}
double rest = 0.0;
for (int i = j+1; i < n; i++)
rest += abs(inv(r, i));
if (maxval < 1e-20*rest)
{
throw Exception ("Inverse matrix: Matrix singular");
}
// exchange rows
if (r > j)
{
for (int k = 0; k < n; k++)
swap (inv(k, j), inv(k, r));
swap (p[j], p[r]);
}
// transformation
T2 hr;
CalcInverse (inv(j,j), hr);
for (int i = 0; i < n; i++)
{
T2 h = hr * inv(j, i);
inv(j, i) = h;
}
inv(j,j) = hr;
for (int k = 0; k < n; k++)
if (k != j)
{
T2 help = inv(n*k+j);
T2 h = help * hr;
for (int i = 0; i < n; i++)
{
T2 h = help * inv(n*j+i);
inv(n*k+i) -= h;
}
inv(k,j) = -h;
}
}
// row exchange
VectorMem<100,T2> hv(n);
for (int i = 0; i < n; i++)
{
for (int k = 0; k < n; k++) hv(p[k]) = inv(k, i);
for (int k = 0; k < n; k++) inv(k, i) = hv(k);
}
}
void run( const int N, const int M, const int L, const int hyper_threads, const int vector_lanes,
const int nx, const int ny, const int nz, const int ichunk,
const int nang, const int noct, const int ng, const int nmom, const int cmom,
const vector<diag_c>& diag )
{
typedef typename Kokkos::DefaultExecutionSpace device_t;
typedef TeamPolicy<device_t> team_policy_t;
typedef View<double*, device_t> view_1d_t;
typedef View<double**, Kokkos::LayoutLeft, device_t> view_2d_t;
typedef View<double***, Kokkos::LayoutLeft, device_t> view_3d_t;
typedef View<double****, Kokkos::LayoutLeft, device_t> view_4d_t;
typedef View<double*****, Kokkos::LayoutLeft, device_t> view_5d_t;
typedef View<double******, Kokkos::LayoutLeft, device_t> view_6d_t;
typedef View<double*******, Kokkos::LayoutLeft, device_t> view_7d_t;
int id = 1;
int ich = 1;
int jlo = 0;
int jhi = ny-1;
int jst = 1;
int jd = 2;
int klo = 0;
int khi = nz-1;
int kst = 1;
int kd = 2;
double hi = c1;
Kokkos::initialize();
Kokkos::DefaultExecutionSpace::print_configuration(cout);
view_4d_t psii( "psii", nang, ny, nz, ng );
view_4d_t psij( "psij", nang, ichunk, nz, ng );
view_4d_t psik( "psik", nang, ichunk, ny, ng );
view_4d_t jb_in( "jb_in", nang, ichunk, ny, ng ); // jb_in(nang,ichunk,nz,ng)
view_4d_t kb_in( "kb_in", nang, ichunk, ny, ng ); // kb_in(nang,ichunk,nz,ng)
view_6d_t qim( "qim", nang, nx, ny, nz, noct, ng ); // qim(nang,nx,ny,nz,noct,ng)
view_5d_t qtot( "qtot", cmom, nx, ny, nx, ng ); // qtot(cmom,nx,ny,nz,ng)
view_2d_t ec( "ec", nang, cmom ); // ec(nang,cmom)
view_1d_t mu( "mu", nang ); // mu(nang)
view_1d_t w( "w", nang ); // w(nang)
view_1d_t wmu( "wmu", nang ); // wmu(nang)
view_1d_t weta( "weta", nang ); // weta(nang)
view_1d_t wxi( "wxi", nang ); // wxi(nang)
view_1d_t hj( "hj", nang ); // hj(nang)
view_1d_t hk( "hk", nang ); // hk(nang)
view_1d_t vdelt( "vdelt", ng ); // vdelt(ng)
view_6d_t ptr_in( "ptr_in", nang, nx, ny, nz, noct, ng ); // ptr_in(nang,nx,ny,nz,noct,ng)
view_6d_t ptr_out( "ptr_out", nang, nx, ny, nz, noct, ng ); // ptr_out(nang,nx,ny,nz,noct,ng)
view_4d_t flux( "flux", nx, ny, nz, ng ); // flux(nx,ny,nz,ng)
view_5d_t fluxm( "fluxm", cmom-1, nx, ny, nz, ng ); //fluxm(cmom-1,nx,ny,nz,ng)
view_2d_t psi( "psi", nang, M );
view_2d_t pc( "pc", nang, M );
view_4d_t jb_out( "jb_out", nang, ichunk, nz, ng );
view_4d_t kb_out( "kb_out", nang, ichunk, ny, ng );
view_4d_t flkx( "flkx", nx+1, ny, nz, ng );
view_4d_t flky( "flky", nx, ny+1, nz, ng );
view_4d_t flkz( "flkz", nx, ny, nz+1, ng );
view_3d_t hv( "hv", nang, 4, M ); // hv(nang,4,M)
view_3d_t fxhv( "fxhv", nang, 4, M ); // fxhv(nang,4,M)
view_5d_t dinv( "dinv", nang, nx, ny, nz, ng ); // dinv(nang,nx,ny,nz,ng)
view_2d_t den( "den", nang, M ); // den(nang,M)
view_4d_t t_xs( "t_xs", nx, ny, nz, ng ); // t_xs(nx,ny,nz,ng)
const team_policy_t policy( N, hyper_threads, vector_lanes );
for (int ii = 0; ii < n_test_iter; ii++) {
Kokkos::Impl::Timer timer;
for (int oct = 0; oct < noct; oct++) {
parallel_for( policy, dim3_sweep2< team_policy_t,
view_1d_t, view_2d_t, view_3d_t, view_4d_t,
view_5d_t, view_6d_t, view_7d_t >
( M, L,
ng, cmom, noct,
nx, ny, nz, ichunk,
diag,
id, ich, oct,
jlo, jhi, jst, jd,
klo, khi, kst, kd,
psii, psij, psik,
jb_in, kb_in,
qim, qtot, ec,
mu, w,
wmu, weta, wxi,
hi, hj, hk,
vdelt, ptr_in, ptr_out,
flux, fluxm, psi, pc,
jb_out, kb_out,
flkx, flky, flkz,
hv, fxhv, dinv,
den, t_xs ) );
}// end noct
std::cout << " ii " << ii << " elapsed time " << timer.seconds() << std::endl;
} // end n_test_iter
Kokkos::finalize();
}
/** Open the help dialog
*
* This slot is connected to the help action.
*
*/
void RainbruRPG::Gui::QuarantineList::showHelp(){
HelpViewer hv("Server-quarant", this);
hv.exec();
}
// Selection implementation.
std::vector<std::pair<population::size_type,std::vector<population::individual_type>::size_type> >
hv_fair_r_policy::select(const std::vector<population::individual_type> &immigrants, const population &dest) const
{
// Fall back to fair_r_policy when facing a single-objective problem.
if (dest.problem().get_f_dimension() == 1) {
return fair_r_policy(m_rate, m_type).select(immigrants, dest);
}
std::vector<population::individual_type> filtered_immigrants;
filtered_immigrants.reserve(immigrants.size());
// Keeps information on the original indexing of immigrants after we filter out the duplicates
std::vector<unsigned int> original_immigrant_indices;
original_immigrant_indices.reserve(immigrants.size());
// Remove the duplicates from the set of immigrants
std::vector<population::individual_type>::iterator im_it = (const_cast<std::vector<population::individual_type> &>(immigrants)).begin();
unsigned int im_idx = 0;
for( ; im_it != immigrants.end() ; ++im_it) {
decision_vector im_x((*im_it).cur_x);
bool equal = true;
for ( unsigned int idx = 0 ; idx < dest.size() ; ++idx ) {
decision_vector isl_x(dest.get_individual(idx).cur_x);
equal = true;
for (unsigned int d_idx = 0 ; d_idx < im_x.size() ; ++d_idx) {
if (im_x[d_idx] != isl_x[d_idx]) {
equal = false;
break;
}
}
if (equal) {
break;
}
}
if (!equal) {
filtered_immigrants.push_back(*im_it);
original_immigrant_indices.push_back(im_idx);
}
++im_idx;
}
// Computes the number of immigrants to be selected (accounting for the destination pop size)
const population::size_type rate_limit = std::min<population::size_type>(get_n_individuals(dest), boost::numeric_cast<population::size_type>(filtered_immigrants.size()));
// Defines the retvalue
std::vector<std::pair<population::size_type, std::vector<population::individual_type>::size_type> > result;
// Skip the remaining computation if there's nothing to do
if (rate_limit == 0) {
return result;
}
// Makes a copy of the destination population
population pop_copy(dest);
// Merge the immigrants to the copy of the destination population
for (population::size_type i = 0; i < rate_limit; ++i) {
pop_copy.push_back(filtered_immigrants[i].cur_x);
}
// Population fronts stored as indices of individuals.
std::vector< std::vector<population::size_type> > fronts_i = pop_copy.compute_pareto_fronts();
// Population fronts stored as fitness vectors of individuals.
std::vector< std::vector<fitness_vector> > fronts_f (fronts_i.size());
// Nadir point is established manually later, first point is a first "safe" candidate.
fitness_vector refpoint(pop_copy.get_individual(0).cur_f);
// Fill fronts_f with fitness vectors and establish the nadir point
for (unsigned int f_idx = 0 ; f_idx < fronts_i.size() ; ++f_idx) {
fronts_f[f_idx].resize(fronts_i[f_idx].size());
for (unsigned int p_idx = 0 ; p_idx < fronts_i[f_idx].size() ; ++p_idx) {
fronts_f[f_idx][p_idx] = fitness_vector(pop_copy.get_individual(fronts_i[f_idx][p_idx]).cur_f);
// Update the nadir point manually for efficiency.
for (unsigned int d_idx = 0 ; d_idx < fronts_f[f_idx][p_idx].size() ; ++d_idx) {
refpoint[d_idx] = std::max(refpoint[d_idx], fronts_f[f_idx][p_idx][d_idx]);
}
}
}
// Epsilon is added to nadir point
for (unsigned int d_idx = 0 ; d_idx < refpoint.size() ; ++d_idx) {
refpoint[d_idx] += m_nadir_eps;
}
// Vector for maintaining the original indices of points for augmented population as 0 and 1
std::vector<unsigned int> g_orig_indices(pop_copy.size(), 1);
unsigned int no_discarded_immigrants = 0;
// Store which front we process (start with the last front) and the number of processed individuals.
unsigned int front_idx = fronts_i.size(); // front_idx is equal to the size, since it's decremented right in the main loop
unsigned int processed_individuals = 0;
// Pairs of (islander index, islander exclusive hypervolume)
// Second item is updated later
std::vector<std::pair<unsigned int, double> > discarded_islanders;
std::vector<std::pair<unsigned int, double> > point_pairs;
// index of currently processed point in the point_pair vector.
// Initiated to its size (=0) in order to enforce the initial computation on penultimate front.
unsigned int current_point = point_pairs.size();
// Stops when we reduce the augmented population to the size of the original population or when the number of discarded islanders reaches the limit
while (processed_individuals < filtered_immigrants.size() && discarded_islanders.size() < rate_limit) {
// if current front was exhausted, load next one
if (current_point == point_pairs.size()) {
--front_idx;
// Compute contributions
std::vector<double> c;
// If there exist a dominated front for front at index front_idx
if (front_idx + 1 < fronts_f.size()) {
std::vector<fitness_vector> merged_front;
// Reserve the memory and copy the fronts
merged_front.reserve(fronts_f[front_idx].size() + fronts_f[front_idx + 1].size());
copy(fronts_f[front_idx].begin(), fronts_f[front_idx].end(), back_inserter(merged_front));
copy(fronts_f[front_idx + 1].begin(), fronts_f[front_idx +1].end(), back_inserter(merged_front));
hypervolume hv(merged_front, false);
c = hv.contributions(refpoint);
} else {
hypervolume hv(fronts_f[front_idx], false);
c = hv.contributions(refpoint);
}
// Initiate the pairs and sort by second item (exclusive volume)
point_pairs.resize(fronts_f[front_idx].size());
for(unsigned int i = 0 ; i < fronts_f[front_idx].size() ; ++i) {
point_pairs[i] = std::make_pair(i, c[i]);
}
current_point = 0;
std::sort(point_pairs.begin(), point_pairs.end(), sort_point_pairs_asc);
}
unsigned int orig_lc_idx = fronts_i[front_idx][point_pairs[current_point].first];
if (orig_lc_idx < dest.size()) {
discarded_islanders.push_back(std::make_pair(orig_lc_idx, 0.0));
} else {
++no_discarded_immigrants;
}
// Flag given individual as discarded
g_orig_indices[orig_lc_idx] = 0;
++processed_individuals;
++current_point;
}
// Number of non-discarded immigrants
unsigned int no_available_immigrants = boost::numeric_cast<unsigned int>(filtered_immigrants.size() - no_discarded_immigrants);
// Pairs of (immigrant index, immigrant exclusive hypervolume)
// Second item is updated later
std::vector<std::pair<unsigned int, double> > available_immigrants;
available_immigrants.reserve(no_available_immigrants);
for(unsigned int idx = dest.size() ; idx < pop_copy.size() ; ++idx) {
// If the immigrant was not discarded add it to the available set
if ( g_orig_indices[idx] == 1 ) {
available_immigrants.push_back(std::make_pair(idx, 0.0));
}
}
// Aggregate all points to establish the hypervolume contribution of available immigrants and discarded islanders
std::vector<fitness_vector> merged_fronts;
merged_fronts.reserve(pop_copy.size());
for(unsigned int idx = 0 ; idx < pop_copy.size() ; ++idx) {
merged_fronts.push_back(pop_copy.get_individual(idx).cur_f);
}
hypervolume hv(merged_fronts, false);
std::vector<std::pair<unsigned int, double> >::iterator it;
for(it = available_immigrants.begin() ; it != available_immigrants.end() ; ++it) {
(*it).second = hv.exclusive((*it).first, refpoint);
}
for(it = discarded_islanders.begin() ; it != discarded_islanders.end() ; ++it) {
(*it).second = hv.exclusive((*it).first, refpoint);
}
// Sort islanders and immigrants according to exclusive hypervolume
sort(available_immigrants.begin(), available_immigrants.end(), hv_fair_r_policy::ind_cmp);
sort(discarded_islanders.begin(), discarded_islanders.end(), hv_fair_r_policy::ind_cmp);
// Number of exchanges is the minimum of the number of non discarded immigrants and the number of discarded islanders
unsigned int no_exchanges = std::min(boost::numeric_cast<unsigned int>(available_immigrants.size()), boost::numeric_cast<unsigned int>(discarded_islanders.size()));
it = available_immigrants.begin();
std::vector<std::pair<unsigned int, double> >::reverse_iterator r_it = discarded_islanders.rbegin();
// Match the best immigrant (forward iterator) with the worst islander (reverse iterator) no_exchanges times.
for(unsigned int i = 0 ; i < no_exchanges ; ++i) {
// Break if any islander is better than an immigrant
if ((*r_it).second > (*it).second) {
break;
}
// Push the pair (islander_idx, fixed_immigrant_idx) to the results
result.push_back(std::make_pair((*r_it).first, original_immigrant_indices[(*it).first - dest.size()]));
++r_it;
++it;
}
return result;
}
int tester(std::string path_to_files)
{
std::ifstream CH4(path_to_files + "/CH4_hv_cs.dat");
std::ifstream hv(path_to_files + "/solar_flux.dat");
std::string first_line;
getline(CH4,first_line);
getline(hv,first_line);
std::vector<Scalar> CH4_cs;
std::vector<Scalar> CH4_lambda;
std::vector<Scalar> hv_irr;
std::vector<Scalar> hv_lambda;
while(!CH4.eof())
{
Scalar cs,l;
CH4 >> l >> cs;
CH4_lambda.push_back(l);
CH4_cs.push_back(cs);
if(CH4_lambda.size() == 137)break;
}
CH4.close();
while(!hv.eof())
{
Scalar w,l,dw;
hv >> l >> w >> dw;
hv_lambda.push_back(l * 10.L); //nm -> Angström
hv_irr.push_back(w * 1e-4L // * 1e-4: m-2 -> cm-2
/ (Antioch::Constants::Planck_constant<Scalar>() * Antioch::Constants::light_celerity<Scalar>() / l)// /(h*c/lambda): energy -> number of photons
/ 10.); // by Angström
if(hv_lambda.size() == 796)break;
}
hv.close();
Scalar T(1500.L);
Antioch::PhotochemicalRate<Scalar, std::vector<Scalar> > rate_hv(CH4_cs,CH4_lambda);
Antioch::SigmaBinConverter<std::vector<Scalar> > bin;
std::vector<Scalar> sigma_rescaled;
bin.y_on_custom_grid(CH4_lambda,CH4_cs,hv_lambda,sigma_rescaled);
rate_hv.calculate_rate_constant(hv_irr, hv_lambda);
Scalar rate = rate_hv.rate(T);
const Scalar tol = std::numeric_limits<Scalar>::epsilon() * 100;
Scalar rate_exact(0.L);
for(unsigned int il = 0; il < hv_lambda.size() - 1; il++)
{
rate_exact += sigma_rescaled[il] * hv_irr[il] * (hv_lambda[il+1] - hv_lambda[il]);
}
int return_flag = (rate_exact == Scalar(0.L));
if(return_flag)std::cout << "Error: rate is null" << std::endl;
if( std::abs( (rate - rate_exact)/rate_exact ) > tol )
{
std::cout << std::scientific << std::setprecision(16)
<< "Error: Mismatch in rate values." << std::endl
<< "rate = " << rate << std::endl
<< "rate_exact = " << rate_exact << std::endl
<< "relative error = " << std::abs(rate_exact - rate)/rate_exact << std::endl
<< "tolerance = " << tol << std::endl;
return_flag = 1;
}
return return_flag;
}
void dgMatrix::EigenVectors (dgVector &eigenValues, const dgMatrix* const initialGuess)
{
dgMatrix& mat = *this;
dgMatrix eigenVectors (dgGetIdentityMatrix());
if (initialGuess) {
eigenVectors = *initialGuess;
mat = eigenVectors.Transpose4X4() * mat * eigenVectors;
}
dgVector d (mat[0][0], mat[1][1], mat[2][2], dgFloat32 (0.0f));
dgVector b (d);
for (dgInt32 i = 0; i < 50; i++) {
dgFloat32 sm = dgAbsf(mat[0][1]) + dgAbsf(mat[0][2]) + dgAbsf(mat[1][2]);
if (sm < dgFloat32 (1.0e-12f)) {
// order the eigenvalue vectors
dgVector tmp (eigenVectors.m_front * eigenVectors.m_up);
if (tmp % eigenVectors.m_right < dgFloat32(0.0f)) {
dgAssert (0.0f);
eigenVectors.m_right = eigenVectors.m_right.Scale3 (-dgFloat32(1.0f));
}
break;
}
dgFloat32 thresh = dgFloat32 (0.0f);
if (i < 3) {
thresh = (dgFloat32)(0.2f / 9.0f) * sm;
}
dgVector z (dgVector::m_zero);
for (dgInt32 ip = 0; ip < 2; ip ++) {
for (dgInt32 iq = ip + 1; iq < 3; iq ++) {
dgFloat32 g = dgFloat32 (100.0f) * dgAbsf(mat[ip][iq]);
if ((i > 3) && ((dgAbsf(d[ip]) + g) == dgAbsf(d[ip])) && ((dgAbsf(d[iq]) + g) == dgAbsf(d[iq]))) {
mat[ip][iq] = dgFloat32 (0.0f);
} else if (dgAbsf(mat[ip][iq]) > thresh) {
dgFloat32 t;
dgFloat32 h = d[iq] - d[ip];
if (dgAbsf(h) + g == dgAbsf(h)) {
t = mat[ip][iq] / h;
} else {
dgFloat32 theta = dgFloat32 (0.5f) * h / mat[ip][iq];
t = dgFloat32(1.0f) / (dgAbsf(theta) + dgSqrt(dgFloat32(1.0f) + theta * theta));
if (theta < dgFloat32 (0.0f)) {
t = -t;
}
}
dgFloat32 c = dgRsqrt (dgFloat32 (1.0f) + t * t);
dgFloat32 s = t * c;
dgFloat32 tau = s / (dgFloat32(1.0f) + c);
h = t * mat[ip][iq];
z[ip] -= h;
z[iq] += h;
d[ip] -= h;
d[iq] += h;
mat[ip][iq] = dgFloat32(0.0f);
for (dgInt32 j = 0; j <= ip - 1; j ++) {
dgFloat32 g = mat[j][ip];
dgFloat32 h = mat[j][iq];
mat[j][ip] = g - s * (h + g * tau);
mat[j][iq] = h + s * (g - h * tau);
}
for (dgInt32 j = ip + 1; j <= iq - 1; j ++) {
dgFloat32 g = mat[ip][j];
dgFloat32 h = mat[j][iq];
mat[ip][j] = g - s * (h + g * tau);
mat[j][iq] = h + s * (g - h * tau);
}
for (dgInt32 j = iq + 1; j < 3; j ++) {
dgFloat32 g = mat[ip][j];
dgFloat32 h = mat[iq][j];
mat[ip][j] = g - s * (h + g * tau);
mat[iq][j] = h + s * (g - h * tau);
}
dgVector sv (s);
dgVector tauv (tau);
dgVector gv (eigenVectors[ip]);
dgVector hv (eigenVectors[iq]);
eigenVectors[ip] -= sv.CompProduct4 (hv + gv.CompProduct4(tauv));
eigenVectors[iq] += sv.CompProduct4 (gv - hv.CompProduct4(tauv));
}
}
}
b += z;
d = b;
}
eigenValues = d;
*this = eigenVectors;
}
int main( int argc, char **argv )
{
// use an ArgumentParser object to manage the program arguments.
osg::ArgumentParser arguments(&argc,argv);
// set up the usage document, in case we need to print out how to use this program.
arguments.getApplicationUsage()->setApplicationName(arguments.getApplicationName());
arguments.getApplicationUsage()->setDescription(arguments.getApplicationName()+" is a utility for converting between various input and output databases formats.");
arguments.getApplicationUsage()->setCommandLineUsage(arguments.getApplicationName()+" [options] filename ...");
arguments.getApplicationUsage()->addCommandLineOption("-h or --help","Display command line parameters");
arguments.getApplicationUsage()->addCommandLineOption("--help-env","Display environmental variables available");
//arguments.getApplicationUsage()->addCommandLineOption("--formats","List supported file formats");
//arguments.getApplicationUsage()->addCommandLineOption("--plugins","List database olugins");
// if user request help write it out to cout.
if (arguments.read("-h") || arguments.read("--help"))
{
osg::setNotifyLevel(osg::NOTICE);
usage( arguments.getApplicationName().c_str(), 0 );
//arguments.getApplicationUsage()->write(std::cout);
return 1;
}
if (arguments.read("--help-env"))
{
arguments.getApplicationUsage()->write(std::cout, osg::ApplicationUsage::ENVIRONMENTAL_VARIABLE);
return 1;
}
if (arguments.read("--plugins"))
{
osgDB::FileNameList plugins = osgDB::listAllAvailablePlugins();
for(osgDB::FileNameList::iterator itr = plugins.begin();
itr != plugins.end();
++itr)
{
std::cout<<"Plugin "<<*itr<<std::endl;
}
return 0;
}
std::string plugin;
if (arguments.read("--plugin", plugin))
{
osgDB::outputPluginDetails(std::cout, plugin);
return 0;
}
std::string ext;
if (arguments.read("--format", ext))
{
plugin = osgDB::Registry::instance()->createLibraryNameForExtension(ext);
osgDB::outputPluginDetails(std::cout, plugin);
return 0;
}
if (arguments.read("--formats"))
{
osgDB::FileNameList plugins = osgDB::listAllAvailablePlugins();
for(osgDB::FileNameList::iterator itr = plugins.begin();
itr != plugins.end();
++itr)
{
osgDB::outputPluginDetails(std::cout,*itr);
}
return 0;
}
if (arguments.argc()<=1)
{
arguments.getApplicationUsage()->write(std::cout,osg::ApplicationUsage::COMMAND_LINE_OPTION);
return 1;
}
FileNameList fileNames;
OrientationConverter oc;
bool do_convert = false;
if (arguments.read("--use-world-frame"))
{
oc.useWorldFrame(true);
}
std::string str;
while (arguments.read("-O",str))
{
osgDB::ReaderWriter::Options* options = new osgDB::ReaderWriter::Options;
options->setOptionString(str);
osgDB::Registry::instance()->setOptions(options);
}
while (arguments.read("-e",ext))
{
std::string libName = osgDB::Registry::instance()->createLibraryNameForExtension(ext);
osgDB::Registry::instance()->loadLibrary(libName);
}
std::string libName;
while (arguments.read("-l",libName))
{
osgDB::Registry::instance()->loadLibrary(libName);
}
while (arguments.read("-o",str))
{
osg::Vec3 from, to;
if( sscanf( str.c_str(), "%f,%f,%f-%f,%f,%f",
&from[0], &from[1], &from[2],
&to[0], &to[1], &to[2] )
!= 6 )
{
float degrees;
osg::Vec3 axis;
// Try deg-axis format
if( sscanf( str.c_str(), "%f-%f,%f,%f",
°rees, &axis[0], &axis[1], &axis[2] ) != 4 )
{
usage( argv[0], "Orientation argument format incorrect." );
return 1;
}
else
{
oc.setRotation( degrees, axis );
do_convert = true;
}
}
else
{
oc.setRotation( from, to );
do_convert = true;
}
}
while (arguments.read("-s",str))
{
osg::Vec3 scale(0,0,0);
if( sscanf( str.c_str(), "%f,%f,%f",
&scale[0], &scale[1], &scale[2] ) != 3 )
{
usage( argv[0], "Scale argument format incorrect." );
return 1;
}
oc.setScale( scale );
do_convert = true;
}
float simplifyPercent = 1.0;
bool do_simplify = false;
while ( arguments.read( "--simplify",str ) )
{
float nsimp = 1.0;
if( sscanf( str.c_str(), "%f",
&nsimp ) != 1 )
{
usage( argv[0], "Scale argument format incorrect." );
return 1;
}
std::cout << str << " " << nsimp << std::endl;
simplifyPercent = nsimp;
osg::notify( osg::INFO ) << "Simplifying with percentage: " << simplifyPercent << std::endl;
do_simplify = true;
}
while (arguments.read("-t",str))
{
osg::Vec3 trans(0,0,0);
if( sscanf( str.c_str(), "%f,%f,%f",
&trans[0], &trans[1], &trans[2] ) != 3 )
{
usage( argv[0], "Translation argument format incorrect." );
return 1;
}
oc.setTranslation( trans );
do_convert = true;
}
FixTransparencyVisitor::FixTransparencyMode fixTransparencyMode = FixTransparencyVisitor::NO_TRANSPARANCY_FIXING;
std::string fixString;
while(arguments.read("--fix-transparency")) fixTransparencyMode = FixTransparencyVisitor::MAKE_OPAQUE_TEXTURE_STATESET_OPAQUE;
while(arguments.read("--fix-transparency-mode",fixString))
{
if (fixString=="MAKE_OPAQUE_TEXTURE_STATESET_OPAQUE") fixTransparencyMode = FixTransparencyVisitor::MAKE_OPAQUE_TEXTURE_STATESET_OPAQUE;
if (fixString=="MAKE_ALL_STATESET_OPAQUE") fixTransparencyMode = FixTransparencyVisitor::MAKE_ALL_STATESET_OPAQUE;
};
bool pruneStateSet = false;
while(arguments.read("--prune-StateSet")) pruneStateSet = true;
osg::Texture::InternalFormatMode internalFormatMode = osg::Texture::USE_IMAGE_DATA_FORMAT;
while(arguments.read("--compressed") || arguments.read("--compressed-arb")) { internalFormatMode = osg::Texture::USE_ARB_COMPRESSION; }
while(arguments.read("--compressed-dxt1")) { internalFormatMode = osg::Texture::USE_S3TC_DXT1_COMPRESSION; }
while(arguments.read("--compressed-dxt3")) { internalFormatMode = osg::Texture::USE_S3TC_DXT3_COMPRESSION; }
while(arguments.read("--compressed-dxt5")) { internalFormatMode = osg::Texture::USE_S3TC_DXT5_COMPRESSION; }
bool smooth = false;
while(arguments.read("--smooth")) { smooth = true; }
bool addMissingColours = false;
while(arguments.read("--addMissingColours") || arguments.read("--addMissingColors")) { addMissingColours = true; }
bool do_overallNormal = false;
while(arguments.read("--overallNormal") || arguments.read("--overallNormal")) { do_overallNormal = true; }
bool enableObjectCache = false;
while(arguments.read("--enable-object-cache")) { enableObjectCache = true; }
// any option left unread are converted into errors to write out later.
arguments.reportRemainingOptionsAsUnrecognized();
// report any errors if they have occurred when parsing the program arguments.
if (arguments.errors())
{
arguments.writeErrorMessages(std::cout);
return 1;
}
for(int pos=1;pos<arguments.argc();++pos)
{
if (!arguments.isOption(pos))
{
fileNames.push_back(arguments[pos]);
}
}
if (enableObjectCache)
{
if (osgDB::Registry::instance()->getOptions()==0) osgDB::Registry::instance()->setOptions(new osgDB::Options());
osgDB::Registry::instance()->getOptions()->setObjectCacheHint(osgDB::Options::CACHE_ALL);
}
std::string fileNameOut("converted.osg");
if (fileNames.size()>1)
{
fileNameOut = fileNames.back();
fileNames.pop_back();
}
osg::Timer_t startTick = osg::Timer::instance()->tick();
osg::ref_ptr<osg::Node> root = osgDB::readNodeFiles(fileNames);
if (root.valid())
{
osg::Timer_t endTick = osg::Timer::instance()->tick();
osg::notify(osg::INFO)<<"Time to load files "<<osg::Timer::instance()->delta_m(startTick, endTick)<<" ms"<<std::endl;
}
if (pruneStateSet)
{
PruneStateSetVisitor pssv;
root->accept(pssv);
}
if (fixTransparencyMode != FixTransparencyVisitor::NO_TRANSPARANCY_FIXING)
{
FixTransparencyVisitor atv(fixTransparencyMode);
root->accept(atv);
}
if ( root.valid() )
{
if (smooth)
{
osgUtil::SmoothingVisitor sv;
root->accept(sv);
}
if (addMissingColours)
{
AddMissingColoursToGeometryVisitor av;
root->accept(av);
}
auto to_lower = std::bind(&boost::to_lower_copy<std::string>,std::placeholders::_1,std::locale());
// all names to lower
Utils::CommonVisitor<osg::Node> names_lower(
[=](osg::Node& n)->void {
n.setName(to_lower(n.getName()));
});
root->accept(names_lower);
// optimize the scene graph, remove rendundent nodes and state etc.
osgUtil::Optimizer optimizer;
FindNodeVisitor::nodeNamesList list_name;
for(int i=0; i<sizeof(do_not_optimize::names)/sizeof(do_not_optimize::names[0]);++i)
{
list_name.push_back(do_not_optimize::names[i]);
}
FindNodeVisitor findNodes(list_name,FindNodeVisitor::not_exact);
root->accept(findNodes);
const FindNodeVisitor::nodeListType& wln_list = findNodes.getNodeList();
for(auto it = wln_list.begin(); it != wln_list.end(); ++it )
{
optimizer.setPermissibleOptimizationsForObject(*it,0);
}
optimizer.optimize(root.get(),
osgUtil::Optimizer::FLATTEN_STATIC_TRANSFORMS |
osgUtil::Optimizer::REMOVE_REDUNDANT_NODES |
osgUtil::Optimizer::SHARE_DUPLICATE_STATE |
osgUtil::Optimizer::MERGE_GEOMETRY |
osgUtil::Optimizer::MERGE_GEODES |
osgUtil::Optimizer::STATIC_OBJECT_DETECTION );
boost::filesystem::path pathFileOut(fileNameOut);
std::string base_file_name = pathFileOut.parent_path().string() + "/" + pathFileOut.stem().string();
cg::point_3 offset;
bool res = generateBulletFile(base_file_name + ".bullet", root, offset);
if (res)
{
osg::notify(osg::NOTICE)<<"Data written to '"<< base_file_name + ".bullet"<<"'."<< std::endl;
}
else
{
osg::notify(osg::NOTICE)<< "Error Occurred While Writing to "<< base_file_name + ".bullet"<< std::endl;
}
osg::Group* newroot = dynamic_cast<osg::Group*>(findFirstNode(root,"Root"));
if(newroot==nullptr)
{
newroot = new osg::Group;
newroot->setName("Root");
newroot->addChild( root );
root = newroot;
}
std::ofstream filelogic( base_file_name + ".stbin", std::ios_base::binary );
std::ofstream logfile ( base_file_name + std::string("_structure") + ".txt" );
heilVisitor hv(filelogic, logfile, offset);
hv.apply(*root.get());
if( do_convert )
root = oc.convert( root.get() );
FIXME(Without textures useless)
#if 0
const std::string name = pathFileOut.stem().string();
osgDB::FilePathList fpl_;
fpl_.push_back(pathFileOut.parent_path().string() + "/");
std::string mat_file_name = osgDB::findFileInPath(name+".dae.mat.xml", /*fpl.*/fpl_,osgDB::CASE_INSENSITIVE);
MaterialVisitor::namesList nl;
nl.push_back("building");
nl.push_back("default");
nl.push_back("tree");
nl.push_back("ground");
nl.push_back("concrete");
nl.push_back("mountain");
nl.push_back("sea");
nl.push_back("railing");
nl.push_back("panorama");
nl.push_back("plane");
//nl.push_back("rotor"); /// �ללללללללללללל נאסךמלוםעאנטע� ט הטםאלטקוסךטי ףבתועס�
MaterialVisitor mv ( nl, std::bind(&creators::createMaterial,sp::_1,sp::_2,name,sp::_3,sp::_4),creators::computeAttributes,mat::reader::read(mat_file_name));
root->accept(mv);
#endif
if (internalFormatMode != osg::Texture::USE_IMAGE_DATA_FORMAT)
{
std::string ext = osgDB::getFileExtension(fileNameOut);
CompressTexturesVisitor ctv(internalFormatMode);
root->accept(ctv);
ctv.compress();
osgDB::ReaderWriter::Options *options = osgDB::Registry::instance()->getOptions();
if (ext!="ive" || (options && options->getOptionString().find("noTexturesInIVEFile")!=std::string::npos))
{
ctv.write(osgDB::getFilePath(fileNameOut));
}
}
// scrub normals
if ( do_overallNormal )
{
DefaultNormalsGeometryVisitor dngv;
root->accept( dngv );
}
// apply any user-specified simplification
if ( do_simplify )
{
osgUtil::Simplifier simple;
simple.setSmoothing( smooth );
osg::notify( osg::ALWAYS ) << " smoothing: " << smooth << std::endl;
simple.setSampleRatio( simplifyPercent );
root->accept( simple );
}
osgDB::ReaderWriter::WriteResult result = osgDB::Registry::instance()->writeNode(*root,fileNameOut,osgDB::Registry::instance()->getOptions());
if (result.success())
{
osg::notify(osg::NOTICE)<<"Data written to '"<<fileNameOut<<"'."<< std::endl;
}
else if (result.message().empty())
{
osg::notify(osg::NOTICE)<<"Warning: file write to '"<<fileNameOut<<"' not supported."<< std::endl;
}
else
{
osg::notify(osg::NOTICE)<<result.message()<< std::endl;
}
}
else
{
std::vector<population::individual_type> hv_greedy_s_policy::select(population &pop) const
{
// Fall back to best_s_policy when facing a single-objective problem.
if (pop.problem().get_f_dimension() == 1) {
return best_s_policy(m_rate, m_type).select(pop);
}
pagmo_assert(get_n_individuals(pop) <= pop.size());
// Gets the number of individuals to select
const population::size_type migration_rate = get_n_individuals(pop);
// Create a temporary array of individuals.
std::vector<population::individual_type> result;
// Indices of fronts.
std::vector< std::vector< population::size_type> > fronts_i = pop.compute_pareto_fronts();
// Fitness vectors of individuals according to the indices above.
std::vector< std::vector< fitness_vector> > fronts_f (fronts_i.size());
// Nadir point is established manually later, first point is as a first "safe" candidate.
fitness_vector refpoint(pop.get_individual(0).cur_f);
for (unsigned int f_idx = 0 ; f_idx < fronts_i.size() ; ++f_idx) {
fronts_f[f_idx].resize(fronts_i[f_idx].size());
for (unsigned int p_idx = 0 ; p_idx < fronts_i[f_idx].size() ; ++p_idx) {
fronts_f[f_idx][p_idx] = fitness_vector(pop.get_individual(fronts_i[f_idx][p_idx]).cur_f);
// Update the nadir point manually for efficiency.
for (unsigned int d_idx = 0 ; d_idx < fronts_f[f_idx][p_idx].size() ; ++d_idx) {
refpoint[d_idx] = std::max(refpoint[d_idx], fronts_f[f_idx][p_idx][d_idx]);
}
}
}
// Epsilon is added to nadir point
for (unsigned int d_idx = 0 ; d_idx < refpoint.size() ; ++d_idx) {
refpoint[d_idx] += m_nadir_eps;
}
// Store which front we process (start with front 0) and the number of processed individuals.
unsigned int front_idx = 0;
unsigned int processed_individuals = 0;
// Vector for maintaining the original indices of points
std::vector<unsigned int> orig_indices;
while (processed_individuals < migration_rate) {
// If we need to pull every point from given front anyway, just push back the individuals right away
if (fronts_f[front_idx].size() <= (migration_rate - processed_individuals)) {
for(unsigned int i = 0 ; i < fronts_i[front_idx].size() ; ++i) {
result.push_back(pop.get_individual(fronts_i[front_idx][i]));
}
processed_individuals += fronts_f[front_idx].size();
++front_idx;
} else {
// Prepare the vector for the original indices
if (orig_indices.size() == 0) {
orig_indices.resize(fronts_i[front_idx].size());
iota(orig_indices.begin(), orig_indices.end(), 0);
}
// Compute the greatest contributor
hypervolume hv(fronts_f[front_idx], false);
hv.set_copy_points(false);
unsigned int gc_idx = hv.greatest_contributor(refpoint);
result.push_back(pop.get_individual(fronts_i[front_idx][orig_indices[gc_idx]]));
// Remove it from the front along with its index
orig_indices.erase(orig_indices.begin() + gc_idx);
fronts_f[front_idx].erase(fronts_f[front_idx].begin() + gc_idx);
++processed_individuals;
}
}
return result;
}
