void HistogramTransformation::Make24BitLUT( uint16* lut ) const
{
if ( lut == 0 )
return;
UpdateFlags();
int numberOfThreads = m_parallel ? Min( int( m_maxProcessors ), Thread::NumberOfThreads( uint24_max+1, 256 ) ) : 1;
int itemsPerThread = (uint24_max + 1)/numberOfThreads;
bool useAffinity = m_parallel && Thread::IsRootThread();
PArray<LUT2416Thread> threads;
for ( int i = 0, j = 1; i < numberOfThreads; ++i, ++j )
threads.Add( new LUT2416Thread( lut, *this,
i*itemsPerThread, (j < numberOfThreads) ? j*itemsPerThread : uint24_max+1 ) );
if ( numberOfThreads > 1 )
{
for ( int i = 0; i < numberOfThreads; ++i )
threads[i].Start( ThreadPriority::DefaultMax, useAffinity ? i : -1 );
for ( int i = 0; i < numberOfThreads; ++i )
threads[i].Wait();
}
else
threads[0].Run();
}
template <class P> static
void Apply( GenericImage<P>& image, const HistogramTransformation& H )
{
if ( image.IsEmptySelection() )
return;
image.SetUnique();
Rect r = image.SelectedRectangle();
int h = r.Height();
int numberOfThreads = H.IsParallelProcessingEnabled() ? Min( H.MaxProcessors(), pcl::Thread::NumberOfThreads( h, 1 ) ) : 1;
int rowsPerThread = h/numberOfThreads;
H.UpdateFlags();
size_type N = image.NumberOfSelectedSamples();
if ( image.Status().IsInitializationEnabled() )
image.Status().Initialize( "Histogram transformation", N );
ThreadData<P> data( image, H, N );
PArray<Thread<P> > threads;
for ( int i = 0, j = 1; i < numberOfThreads; ++i, ++j )
threads.Add( new Thread<P>( data, i*rowsPerThread, (j < numberOfThreads) ? j*rowsPerThread : h ) );
AbstractImage::RunThreads( threads, data );
threads.Destroy();
image.Status() = data.status;
}
void
AmrAdv::GetData (int lev, Real time, PArray<MultiFab>& data, std::vector<Real>& datatime)
{
data.clear();
datatime.clear();
const Real teps = (t_new[lev] - t_old[lev]) * 1.e-3;
if (time > t_new[lev] - teps && time < t_new[lev] + teps)
{
data.push_back(phi_new[lev].get());
datatime.push_back(t_new[lev]);
}
else if (time > t_old[lev] - teps && time < t_old[lev] + teps)
{
data.push_back(phi_old[lev].get());
datatime.push_back(t_old[lev]);
}
else
{
data.push_back(phi_old[lev].get());
data.push_back(phi_new[lev].get());
datatime.push_back(t_old[lev]);
datatime.push_back(t_new[lev]);
}
}
void
FMultiGrid::Copy (PArray<MultiFab>& dst, PArray<MultiFab>& src)
{
int nlevels = src.size();
dst.resize(nlevels);
for (int ilev = 0; ilev < nlevels; ++ilev) {
dst.set(ilev, &src[ilev]);
}
}
std::string Variable::printArray(PArray array, std::string indent)
{
std::ostringstream result;
result << indent << "(Array length=" << array->size() << ")" << std::endl << indent << "{" << std::endl;
std::string currentIndent = indent;
currentIndent.push_back(' ');
currentIndent.push_back(' ');
for(std::vector<std::shared_ptr<Variable>>::iterator i = array->begin(); i != array->end(); ++i)
{
result << print(*i, currentIndent);
}
result << indent << "}" << std::endl;
return result.str();
}
void average_face_to_cellcenter (MultiFab& cc, const PArray<MultiFab>& fc, const Geometry& geom)
{
BL_ASSERT(cc.nComp() >= BL_SPACEDIM);
BL_ASSERT(fc.size() == BL_SPACEDIM);
BL_ASSERT(fc[0].nComp() == 1); // We only expect fc to have the gradient perpendicular to the face
const Real* dx = geom.CellSize();
const Real* problo = geom.ProbLo();
int coord_type = Geometry::Coord();
#ifdef _OPENMP
#pragma omp parallel
#endif
for (MFIter mfi(cc,true); mfi.isValid(); ++mfi)
{
const Box& bx = mfi.tilebox();
BL_FORT_PROC_CALL(BL_AVG_FC_TO_CC,bl_avg_fc_to_cc)
(bx.loVect(), bx.hiVect(),
BL_TO_FORTRAN(cc[mfi]),
D_DECL(BL_TO_FORTRAN(fc[0][mfi]),
BL_TO_FORTRAN(fc[1][mfi]),
BL_TO_FORTRAN(fc[2][mfi])),
dx, problo, coord_type);
}
}
void
FMultiGrid::Copy (Array<PArray<MultiFab> >& dst, PArray<MultiFab>& src)
{
int ndim = src.size();
dst.resize(1);
dst[0].resize(ndim);
for(int idim = 0; idim < ndim; ++idim) {
dst[0].set(idim, &src[idim]);
}
}
void
FMultiGrid::set_mac_coeffs (PArray<MultiFab>& b)
{
BL_ASSERT(m_coeff.eq_type == invalid_eq);
BL_ASSERT(m_nlevels == 1);
BL_ASSERT(b.size() == BL_SPACEDIM);
m_coeff.eq_type = macproj_eq;
m_coeff.coeffs_set = true;
Copy(m_coeff.b, b);
}
void
FMultiGrid::set_coefficients (PArray<MultiFab>& a, Array<PArray<MultiFab> > & b)
{
BL_ASSERT(m_coeff.eq_type == invalid_eq || m_coeff.eq_type == general_eq);
BL_ASSERT(!m_coeff.coeffs_set);
BL_ASSERT(m_nlevels == a.size() && m_nlevels == b.size());
BL_ASSERT(BL_SPACEDIM == b[0].size());
m_coeff.eq_type = general_eq;
m_coeff.coeffs_set = true;
Copy(m_coeff.a, a);
Copy(m_coeff.b, b);
}
// Average fine face-based MultiFab onto crse fine-centered MultiFab.
// This routine assumes that the crse BoxArray is a coarsened version of the fine BoxArray.
void average_down_faces (PArray<MultiFab>& fine, PArray<MultiFab>& crse, IntVect& ratio)
{
BL_ASSERT(crse.size() == BL_SPACEDIM);
BL_ASSERT(fine.size() == BL_SPACEDIM);
BL_ASSERT(crse[0].nComp() == 1);
BL_ASSERT(fine[0].nComp() == 1);
#ifdef _OPENMP
#pragma omp parallel
#endif
for (int n=0; n<BL_SPACEDIM; ++n) {
for (MFIter mfi(crse[n],true); mfi.isValid(); ++mfi)
{
const Box& tbx = mfi.tilebox();
BL_FORT_PROC_CALL(BL_AVGDOWN_FACES,bl_avgdown_faces)
(tbx.loVect(),tbx.hiVect(),
BL_TO_FORTRAN(fine[n][mfi]),
BL_TO_FORTRAN(crse[n][mfi]),
ratio.getVect(),n);
}
}
}
FMultiGrid::FMultiGrid (const PArray<Geometry> & geom,
int baselevel,
IntVect crse_ratio)
:
m_nlevels(geom.size()),
m_baselevel(baselevel),
m_crse_ratio(crse_ratio),
m_stencil(CC_CROSS_STENCIL),
m_maxorder(0),
m_verbose(0),
m_geom(m_nlevels),
m_bndry(0),
m_mgt_solver(0)
{
for (int ilev = 0; ilev < m_nlevels; ++ilev) {
m_geom[ilev] = geom[ilev];
}
if (m_baselevel > 0 && m_crse_ratio == IntVect::TheZeroVector())
BoxLib::Abort("FMultiGrid: must set crse_ratio if baselevel > 0");
}
void average_cellcenter_to_face (PArray<MultiFab>& fc, const MultiFab& cc, const Geometry& geom)
{
BL_ASSERT(cc.nComp() == 1);
BL_ASSERT(cc.nGrow() >= 1);
BL_ASSERT(fc.size() == BL_SPACEDIM);
BL_ASSERT(fc[0].nComp() == 1); // We only expect fc to have the gradient perpendicular to the face
const Real* dx = geom.CellSize();
const Real* problo = geom.ProbLo();
int coord_type = Geometry::Coord();
#ifdef _OPENMP
#pragma omp parallel
#endif
for (MFIter mfi(cc,true); mfi.isValid(); ++mfi)
{
const Box& xbx = mfi.nodaltilebox(0);
#if (BL_SPACEDIM > 1)
const Box& ybx = mfi.nodaltilebox(1);
#endif
#if (BL_SPACEDIM == 3)
const Box& zbx = mfi.nodaltilebox(2);
#endif
BL_FORT_PROC_CALL(BL_AVG_CC_TO_FC,bl_avg_cc_to_fc)
(xbx.loVect(), xbx.hiVect(),
#if (BL_SPACEDIM > 1)
ybx.loVect(), ybx.hiVect(),
#endif
#if (BL_SPACEDIM == 3)
zbx.loVect(), zbx.hiVect(),
#endif
D_DECL(BL_TO_FORTRAN(fc[0][mfi]),
BL_TO_FORTRAN(fc[1][mfi]),
BL_TO_FORTRAN(fc[2][mfi])),
BL_TO_FORTRAN(cc[mfi]),
dx, problo, coord_type);
}
}
void
solve_for_accel(PArray<MultiFab>& rhs, PArray<MultiFab>& phi, PArray<MultiFab>& grad_phi,
const Array<Geometry>& geom, int base_level, int finest_level, Real offset)
{
Real tol = 1.e-10;
Real abs_tol = 1.e-14;
Array< PArray<MultiFab> > grad_phi_edge;
grad_phi_edge.resize(rhs.size());
for (int lev = base_level; lev <= finest_level ; lev++)
{
grad_phi_edge[lev].resize(BL_SPACEDIM, PArrayManage);
for (int n = 0; n < BL_SPACEDIM; ++n)
grad_phi_edge[lev].set(n, new MultiFab(BoxArray(rhs[lev].boxArray()).surroundingNodes(n), 1, 1));
}
Real strt = ParallelDescriptor::second();
// ***************************************************
// Make sure the RHS sums to 0 if fully periodic
// ***************************************************
for (int lev = base_level; lev <= finest_level; lev++) {
Real n0 = rhs[lev].norm0();
if (ParallelDescriptor::IOProcessor())
std::cout << "Max of rhs in solve_for_phi before correction at level "
<< lev << " " << n0 << std::endl;
}
for (int lev = base_level; lev <= finest_level; lev++)
rhs[lev].plus(-offset, 0, 1, 0);
for (int lev = base_level; lev <= finest_level; lev++) {
Real n0 = rhs[lev].norm0();
if (ParallelDescriptor::IOProcessor())
std::cout << "Max of rhs in solve_for_phi after correction at level "
<< lev << " " << n0 << std::endl;
}
// ***************************************************
// Solve for phi and return both phi and grad_phi_edge
// ***************************************************
#ifdef USEHPGMG
solve_with_hpgmg(rhs,phi,grad_phi_edge,geom,base_level,finest_level,tol,abs_tol);
#else
solve_with_f90 (rhs,phi,grad_phi_edge,geom,base_level,finest_level,tol,abs_tol);
#endif
// Average edge-centered gradients to cell centers.
for (int lev = base_level; lev <= finest_level; lev++)
{
BoxLib::average_face_to_cellcenter(grad_phi[lev], grad_phi_edge[lev], geom[lev]);
geom[lev].FillPeriodicBoundary(grad_phi[lev],true); // wz: why only fill periodic boundary?
}
// VisMF::Write(grad_phi,"GradPhi");
{
const int IOProc = ParallelDescriptor::IOProcessorNumber();
Real end = ParallelDescriptor::second() - strt;
#if 0
#ifdef BL_LAZY
Lazy::QueueReduction( [=] () mutable {
#endif
ParallelDescriptor::ReduceRealMax(end,IOProc);
if (ParallelDescriptor::IOProcessor())
std::cout << "solve_for_phi() time = " << end << std::endl;
#ifdef BL_LAZY
});
#endif
#endif
}
}
void
FMultiGrid::Copy (PArray<MultiFab>& dst, const MultiFab& src)
{
dst.resize(1);
dst.set(0, &src);
}