#include <ERF_LatLonMap.H>

Collaboration diagram for LatLonMap:

[legend]

Public Member Functions
	LatLonMap (const amrex::MultiFab &lat, const amrex::MultiFab &lon, const amrex::BoxArray &ba2d, const amrex::DistributionMapping &dm, const amrex::Geometry &geom0)

LatLonStatus	locate (amrex::Real req_lat, amrex::Real req_lon, LatLonLocation &loc) const

void	rotation_at (amrex::Real x, amrex::Real y, amrex::Real &cos_alpha, amrex::Real &sin_alpha) const

Private Attributes
amrex::MultiFab	m_ll

amrex::Box	m_dom

amrex::GpuArray< amrex::Real, AMREX_SPACEDIM >	m_problo

amrex::GpuArray< amrex::Real, AMREX_SPACEDIM >	m_dx

Constructor & Destructor Documentation

◆ LatLonMap()

LatLonMap::LatLonMap	(	const amrex::MultiFab &	lat,
		const amrex::MultiFab &	lon,
		const amrex::BoxArray &	ba2d,
		const amrex::DistributionMapping &	dm,
		const amrex::Geometry &	geom0
	)

     : m_problo(geom0.ProbLoArray()),
       m_dx(geom0.CellSizeArray())
 {
     m_dom = geom0.Domain();
     m_dom.setRange(2,0);
  
     // Gather the level-0 mass-point latitude and longitude onto the IO rank.
     // This is a setup-time, level-0, 2D array, so the gather is affordable and
     // keeps the search and the inverse map as plain host code.
     //
     // The ceiling is one rank holding 2 Reals per level-0 column -- 100 MB or
     // so for the largest domains ERF is run on -- and a search of that array
     // per point, once.
     MultiFab latlon(ba2d, dm, 2, 0);
     pack_latlon(latlon, lat, lon);
  
     BoxArray ba_one(m_dom);
     Vector<int> pmap(1, ParallelDescriptor::IOProcessorNumber());
     DistributionMapping dm_one(pmap);
     m_ll.define(ba_one, dm_one, 2, 0, MFInfo().SetArena(The_Pinned_Arena()));
     m_ll.ParallelCopy(latlon, 0, 0, 2);
  
     // The copy is device-side in a GPU build; the searches are host code
     Gpu::streamSynchronize();
 }

Here is the call graph for this function:

Member Function Documentation

◆ locate()

LatLonStatus LatLonMap::locate	(	amrex::Real	req_lat,
		amrex::Real	req_lon,
		LatLonLocation &	loc
	)		const

 {
     Real out[9] = {Real(0.0), Real(0.0), Real(0.0), Real(0.0), Real(0.0),
                    Real(0.0), Real(0.0), Real(0.0), Real(0.0)};
  
     if (ParallelDescriptor::IOProcessor()) {
         LatLonLocation l;
         const LatLonStatus status = locate_latlon_on_grid(m_ll.const_array(0), m_dom, m_problo, m_dx,
                                                           req_lat, req_lon, l);
         out[0] = l.x;        out[1] = l.y;
         out[2] = l.lat;      out[3] = l.lon;
         out[4] = l.near_lat; out[5] = l.near_lon;
         out[6] = l.cos_alpha; out[7] = l.sin_alpha;
         out[8] = static_cast<Real>(static_cast<int>(status));
     }
  
     ParallelDescriptor::Bcast(out, 9, ParallelDescriptor::IOProcessorNumber());
  
     loc.x = out[0];        loc.y = out[1];
     loc.lat = out[2];      loc.lon = out[3];
     loc.near_lat = out[4]; loc.near_lon = out[5];
     loc.cos_alpha = out[6]; loc.sin_alpha = out[7];
     return static_cast<LatLonStatus>(static_cast<int>(std::lround(out[8])));
 }

Referenced by ObsNudging::resolve_positions(), and ERF::resolve_station_positions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rotation_at()

void LatLonMap::rotation_at	(	amrex::Real	x,
		amrex::Real	y,
		amrex::Real &	cos_alpha,
		amrex::Real &	sin_alpha
	)		const

 {
     Real out[2] = {Real(1.0), Real(0.0)};
  
     if (ParallelDescriptor::IOProcessor()) {
         const int i = std::clamp(static_cast<int>(std::floor((x - m_problo[0]) / m_dx[0])),
                                  m_dom.smallEnd(0), m_dom.bigEnd(0));
         const int j = std::clamp(static_cast<int>(std::floor((y - m_problo[1]) / m_dx[1])),
                                  m_dom.smallEnd(1), m_dom.bigEnd(1));
         grid_rotation_from_latlon(m_ll.const_array(0), m_dom, i, j, out[0], out[1]);
     }
  
     ParallelDescriptor::Bcast(out, 2, ParallelDescriptor::IOProcessorNumber());
     cos_alpha = out[0];
     sin_alpha = out[1];
 }