//**********************************************************************
PHX_EVALUATE_FIELDS(Equations,workset)
{ 
  for (int i=0; i < residual_temp.size(); ++i)
    residual_temp[i] = 0.0;

  for (int i=0; i < residual_vel.size(); ++i)
    residual_vel[i] = 0.0;

  std::vector<Element_Linear2D>::iterator element = workset.begin;
  
  for (std::size_t cell = 0; cell < workset.num_cells; ++cell,++element) {
    
    const Kokkos::View<double**,PHX::Device> phi = element->basisFunctions();

    const Kokkos::View<double***,PHX::Device> grad_phi = element->basisFunctionGradientsRealSpace();

    const Kokkos::View<double*,PHX::Device> det_jac =  element->detJacobian();

    const Kokkos::View<double*,PHX::Device> weights = element->quadratureWeights();

    for (int node = 0; node < element->numNodes(); ++node) {
      
      for (int qp = 0; qp < num_qp; ++qp) {

	residual_temp(cell,node) += det_jac(qp) * weights(qp) *
	  ( grad_phi(qp,node,0) * grad_temp(cell,qp,0) 
	    + grad_phi(qp,node,1) * grad_temp(cell,qp,1)
	    + 1000.0 * phi(qp,node) * temp(cell,qp) * vel(cell,qp) );
	
	residual_vel(cell,node) += det_jac(qp) * weights(qp) *
	  ( grad_phi(qp,node,0) * grad_vel(cell,qp,0) 
	    + grad_phi(qp,node,1) * grad_vel(cell,qp,1)
	    + 1000.0 * phi(qp,node) * temp(cell,qp) * vel(cell,qp) );
	
      }
      
    }

  }
   
//   std::cout << "Temp Residual" << std::endl;
//   residual_temp.print(std::cout,true);
//   std::cout << "Vx Residual" << std::endl;
//   residual_vel.print(std::cout,true);
 
}
KOKKOS_INLINE_FUNCTION
void Fourier<EvalT, Traits>::operator () (const int i) const
{
  for (PHX::index_size_type qp = 0; qp < num_qp; ++qp)
    for (PHX::index_size_type dim = 0; dim < num_dim; ++dim)
      flux(i,qp,dim) =
	- density(i,qp) * dc(i,qp) * grad_temp(i,qp,dim);
}
void DataProcessing::computeGradient(
	const std::vector<double>& alt,
	const std::vector<double>& dist,
	std::vector<double>& grad)
{
	assert(alt.size() == dist.size());
	assert(alt.size() > 1);

	// Compute gradient from altitude
	const double grad_limit = 30.0; // define a max grad (incase of noise in signal)
	std::vector<double> grad_temp(alt.size());
	for (unsigned int i=1; i < alt.size(); ++i)
	{
		if (dist[i] - dist[i-1] > 1.0)
			grad_temp[i] = std::min(std::max(100*(alt[i] - alt[i-1])/(dist[i] - dist[i-1]), -grad_limit),grad_limit);
	}

	grad.resize(alt.size());
	DataProcessing::lowPassFilterSignal(grad_temp,grad,10);
}