自学教程：C++ temperature函数代码示例

void MixedSolventElectrolyte::s_update_dlnActCoeff_dlnN_diag() const{    int delAK, delBK;    double XA, XB, XK, g0, g1;    double T = temperature();    double RT = GasConstant*T;    dlnActCoeffdlnN_diag_.assign(m_kk, 0);    for (size_t iK = 0; iK < m_kk; iK++) {        XK = moleFractions_[iK];        for (size_t i = 0; i <  numBinaryInteractions_; i++) {            size_t iA =  m_pSpecies_A_ij[i];            size_t iB =  m_pSpecies_B_ij[i];            delAK = 0;            delBK = 0;            if (iA==iK) {                delAK = 1;            } else if (iB==iK) {                delBK = 1;            }            XA = moleFractions_[iA];            XB = moleFractions_[iB];            g0 = (m_HE_b_ij[i] - T * m_SE_b_ij[i]) / RT;            g1 = (m_HE_c_ij[i] - T * m_SE_c_ij[i]) / RT;            dlnActCoeffdlnN_diag_[iK] += 2*(delBK-XB)*(g0*(delAK-XA)+g1*(2*(delAK-XA)*XB+XA*(delBK-XB)));            // double gfac = g0 + g1 * XB;            // double gggg = (delBK - XB) * g1;            // dlnActCoeffdlnN_diag_[iK] += gfac * delAK * ( - XB + delBK);            // dlnActCoeffdlnN_diag_[iK] += gfac * delBK * ( - XA + delAK);            // dlnActCoeffdlnN_diag_[iK] += gfac * (2.0 * XA * XB - delAK * XB - XA * delBK);            // dlnActCoeffdlnN_diag_[iK] += (delAK * XB + XA * delBK - XA * XB) * g1 * (-XB + delBK);            // dlnActCoeffdlnN_diag_[iK] += gggg * ( - 2.0 * XA * XB + delAK * XB + XA * delBK);            // dlnActCoeffdlnN_diag_[iK] += - g1 * XA * XB * (- XB + delBK);        }        dlnActCoeffdlnN_diag_[iK] = XK*dlnActCoeffdlnN_diag_[iK];//-XK;    }}

 void watch(const FuncT& f) {     for(;;) {         wait_for_data();         f(             wetness(),             temperature(),             atmospheric_pressure(),             illumination()         );     } }

 void ConstDensityThermo::getChemPotentials(doublereal* mu) const {     doublereal vdp = (pressure() - m_spthermo->refPressure())/                      molarDensity();     doublereal xx;     doublereal rt = temperature() * GasConstant;     const array_fp& g_RT = gibbs_RT();     for (int k = 0; k < m_kk; k++) {         xx = fmaxx(SmallNumber, moleFraction(k));         mu[k] = rt*(g_RT[k] + log(xx)) + vdp;     } }

void Reactor::updateState(doublereal* y){    // The components of y are [0] the total mass, [1] the total volume,    // [2] the total internal energy, [3...K+3] are the mass fractions of each    // species, and [K+3...] are the coverages of surface species on each wall.    m_mass = y[0];    m_vol = y[1];    m_thermo->setMassFractions_NoNorm(y+3);    if (m_energy) {        // Use a damped Newton's method to determine the mixture temperature.        // Tight tolerances are required both for Jacobian evaluation and for        // sensitivity analysis to work correctly.        doublereal U = y[2];        doublereal T = temperature();        double dT = 100;        double dUprev = 1e10;        double dU = 1e10;        int i = 0;        double damp = 1.0;        while (abs(dT / T) > 10 * DBL_EPSILON) {            dUprev = dU;            m_thermo->setState_TR(T, m_mass / m_vol);            double dUdT = m_thermo->cv_mass() * m_mass;            dU = m_thermo->intEnergy_mass() * m_mass - U;            dT = dU / dUdT;            // Reduce the damping coefficient if the magnitude of the error            // isn't decreasing            if (std::abs(dU) < std::abs(dUprev)) {                damp = 1.0;            } else {                damp *= 0.8;            }            dT = std::min(dT, 0.5 * T) * damp;            T -= dT;            i++;            if (i > 100) {                throw CanteraError("Reactor::updateState",                    "no convergence/nU/m = {}/nT = {}/nrho = {}/n",                    U / m_mass, T, m_mass / m_vol);            }        }    } else {        m_thermo->setDensity(m_mass/m_vol);    }    updateSurfaceState(y + m_nsp + 3);    // save parameters needed by other connected reactors    m_enthalpy = m_thermo->enthalpy_mass();    m_pressure = m_thermo->pressure();    m_intEnergy = m_thermo->intEnergy_mass();    m_thermo->saveState(m_state);}

//function is fed with a priority queue of action-values //generates Boltzmann distribution of these action-values//and selects an action based on probabilities float selectAction(PriorityQueue<float, double>& a_queue, unsigned long iterations){	typedef std::vector<std::pair<float, double>> VecPair ; 		//turn priority queue into a vector of pairs	VecPair vec = a_queue.saveOrderedQueueAsVector();	    //sum for partition function 	double sum = 0;		// calculate partition function by iterating over action-values	for (VecPair::iterator iter = vec.begin(), end = vec.end(); iter < end; ++iter)	{		sum += std::exp((iter->second) / temperature(iterations));	}		//compute Boltzmann factors for action-values and enqueue to vec	for (VecPair::iterator iter = vec.begin(); iter < vec.end(); ++iter)	{		iter->second = std::exp(iter->second / temperature(iterations)) / sum;	}		//calculate cumulative probability distribution	for (VecPair::iterator iter = vec.begin()++, end = vec.end(); iter < end; ++iter)	{	//second member of pair becomes addition of its current value	//and that of the index before it	iter->second += (iter-1)->second;	}		//generate RN between 0 and 1	double rand_num = static_cast<double>(rand()) / RAND_MAX;		// choose action based on random number relation to priorities within action queue	for (VecPair::iterator iter = vec.begin(), end = vec.end(); iter < end; ++iter)	{		if (rand_num < iter->second)return iter->first;	}		return -10; //note that this line should never be reached	}

void StatisticsSampler::saveToFile(System &system, ofstream &file){    // Convert all energy per atom, use eV    file << setw(15) << UnitConverter::timeToSI(system.steps()) << "      "         << setw(15) << UnitConverter::timeToSI(system.time()) << "      "         << setw(15) << UnitConverter::temperatureToSI(temperature()) << "      "         << setw(15) << UnitConverter::energyToEv(kineticEnergy()/system.atoms().size()) << "      "         << setw(15) << UnitConverter::energyToEv(potentialEnergy()/system.atoms().size()) << "      "         << setw(15) << UnitConverter::energyToEv(totalEnergy()/system.atoms().size()) << "      "         << setw(15) << diffusionConstant() << "      "         << setw(15) << m_rSquared << std::endl;}

 /*  * cv_mole():  *  *  Molar heat capacity at constant volume of the mixture.   *  Units: J/kmol/K.   *  *  For single species, we go directory to the   *  general Cp - Cv relation  *  *  Cp = Cv + alpha**2 * V * T / beta  *  * where   *     alpha = volume thermal expansion coefficient  *     beta  = isothermal compressibility  */ doublereal SingleSpeciesTP::cv_mole() const {   doublereal cvbar = cp_mole();   doublereal alpha = thermalExpansionCoeff();   doublereal beta = isothermalCompressibility();   doublereal molecW = molecularWeight(0);   doublereal V = molecW/density();   doublereal T = temperature();   if (beta != 0.0) {     cvbar -= alpha * alpha * V * T / beta;   }   return cvbar; }

void LatticePhase::_updateThermo() const{    doublereal tnow = temperature();    if (m_tlast != tnow) {        m_spthermo->update(tnow, &m_cp0_R[0], &m_h0_RT[0], &m_s0_R[0]);        m_tlast = tnow;        for (size_t k = 0; k < m_kk; k++) {            m_g0_RT[k] = m_h0_RT[k] - m_s0_R[k];        }        m_tlast = tnow;    }}

int tester(const std::string & input_file){//temperature  std::vector<Scalar> T0,Tz;  read_temperature<Scalar>(T0,Tz,input_file);  gsl_interp_accel * acc = gsl_interp_accel_alloc();  gsl_spline       * spline = gsl_spline_alloc(gsl_interp_cspline, T0.size());  // GLS takes only double, raaaaahhhh  std::vector<double> gsl_x_point(T0.size(),0);  std::vector<double> gsl_y_point(T0.size(),0);  for(unsigned int i = 0; i < T0.size(); i++)  {    gsl_x_point[i] = (const double)Tz[i];    gsl_y_point[i] = (const double)T0[i];  }  const double * x = &gsl_x_point[0];  const double * y = &gsl_y_point[0];  gsl_spline_init(spline, x, y, T0.size());  Planet::AtmosphericTemperature<Scalar,std::vector<Scalar> > temperature(Tz,T0); //neutral, ionic, altitude  int return_flag(0);  const Scalar tol = (std::numeric_limits<Scalar>::epsilon() * 100. < 6e-17)?6e-17:                      std::numeric_limits<Scalar>::epsilon() * 100.;  for(Scalar z = 600.; z < 1401.; z += 10)  {      Scalar neu_temp  = gsl_spline_eval(spline,z,acc);      Scalar neu_dtemp = gsl_spline_eval_deriv(spline,z,acc);      Scalar ion_temp  = gsl_spline_eval(spline,z,acc);      Scalar ion_dtemp = gsl_spline_eval_deriv(spline,z,acc);      Scalar e_temp    = electron_temperature(z);      Scalar de_dtemp  = delectron_temperature(z);      return_flag = check(temperature.neutral_temperature(z),        neu_temp,  tol, "neutral temperature")               ||                    check(temperature.dneutral_temperature_dz(z),    neu_dtemp, tol, "neutral temperature differentiate") ||                    check(temperature.ionic_temperature(z),          ion_temp,  tol, "ionic temperature")                 ||                    check(temperature.dionic_temperature_dz(z),      ion_dtemp, tol, "ionic temperature differentiate")   ||                    check(temperature.electronic_temperature(z),     e_temp,    tol, "electron temperature")              ||                    check(temperature.delectronic_temperature_dz(z), de_dtemp,  tol, "electron temperature differentiate") ||                    return_flag;  }  gsl_spline_free(spline);  gsl_interp_accel_free(acc);  return return_flag;}

 void ConstDensityThermo::_updateThermo() const {     doublereal tnow = temperature();     if (m_tlast != tnow) {         m_spthermo->update(tnow, &m_cp0_R[0], &m_h0_RT[0],              &m_s0_R[0]);         m_tlast = tnow;         int k;         for (k = 0; k < m_kk; k++) {             m_g0_RT[k] = m_h0_RT[k] - m_s0_R[k];         }         m_tlast = tnow;     } }

void VPSSMgr_IdealGas::_updateStandardStateThermo(){    doublereal pp = log(m_plast / m_p0);    doublereal v = temperature() *GasConstant /m_plast;    for (size_t k = 0; k < m_kk; k++) {        m_hss_RT[k] = m_h0_RT[k];        m_cpss_R[k] = m_cp0_R[k];        m_sss_R[k] = m_s0_R[k] - pp;        m_gss_RT[k] = m_hss_RT[k] - m_sss_R[k];        m_Vss[k] = v;    }}

void RedlichKisterVPSSTP::s_update_dlnActCoeff_dlnX_diag() const{    doublereal T = temperature();    dlnActCoeffdlnX_diag_.assign(m_kk, 0.0);      for (size_t i = 0; i <  numBinaryInteractions_; i++) {      size_t iA =  m_pSpecies_A_ij[i];      size_t iB =  m_pSpecies_B_ij[i];      double XA = moleFractions_[iA];      double XB = moleFractions_[iB];      doublereal deltaX = XA - XB;      size_t N = m_N_ij[i];      doublereal poly = 1.0;      doublereal sum = 0.0;      vector_fp& he_vec = m_HE_m_ij[i];      vector_fp& se_vec = m_SE_m_ij[i];      doublereal sumMm1 = 0.0;      doublereal polyMm1 = 1.0;      doublereal polyMm2 = 1.0;      doublereal sumMm2 = 0.0;      for (size_t m = 0; m < N; m++) {	doublereal A_ge = (he_vec[m] -  T * se_vec[m]) / (GasConstant * T);;	sum += A_ge * poly;	poly *= deltaX;	if (m >= 1) {	  sumMm1  += (A_ge * polyMm1 * m);	  polyMm1 *= deltaX;	}	if (m >= 2) {	  sumMm2 += (A_ge * polyMm2 * m * (m - 1.0));	  polyMm2 *= deltaX;	}      }      for (size_t k = 0; k < m_kk; k++) {	if (iA == k) {	      	  dlnActCoeffdlnX_diag_[k] += XA * (- (1-XA+XB) * sum + 2*(1.0 - XA) * XB * sumMm1					    +  sumMm1 * (XB *(1.0 - 2.0 * XA + XB) - XA * (1.0 - XA + 2*XB) )					    + 2 * XA * XB * sumMm2 * (1.0 - XA + XB));	} else  if (iB == k) {	  dlnActCoeffdlnX_diag_[k] += XB * (- (1-XB+XA) * sum - 2*(1.0 - XB) * XA * sumMm1					    + sumMm1 * (XA * (XB - XA - (1.0 - XB)) -XB * (-2.0*XA + XB - 1) )					    - 2 * XA * XB * sumMm2 * (-XA - (1.0 - XB)));	}      }    }}

doublereal WaterSSTP::vaporFraction() const{    if (temperature() >= m_sub.Tcrit()) {        double dens = density();        if (dens >= m_sub.Rhocrit()) {            return 0.0;        }        return 1.0;    }    /*     * If below tcrit we always return 0 from this class     */    return 0.0;}

void SingleSpeciesTP::setState_HP(doublereal h, doublereal p,                                  doublereal tol){    doublereal dt;    setPressure(p);    for (int n = 0; n < 50; n++) {        dt = clip((h - enthalpy_mass())/cp_mass(), -100.0, 100.0);        setState_TP(temperature() + dt, p);        if (fabs(dt) < tol) {            return;        }    }    throw CanteraError("setState_HP","no convergence. dt = " + fp2str(dt));}

void Reactor::updateState(doublereal* y){    ThermoPhase& mix = *m_thermo;  // define for readability    // The components of y are the total internal energy,    // the total volume, and the mass of each species.    // Set the mass fractions and  density of the mixture.    doublereal u   = y[0];    m_vol          = y[1];    doublereal* mss = y + 2;    doublereal mass = accumulate(y+2, y+2+m_nsp, 0.0);    m_thermo->setMassFractions(mss);    m_thermo->setDensity(mass/m_vol);    doublereal temp = temperature();    mix.setTemperature(temp);    if (m_energy) {        // Decreased the tolerance on delta_T to 1.0E-7 so that T is        // accurate to 9 sig digits, because this is        // used in the numerical jacobian routines where relative values        // of 1.0E-7 are used in the deltas.        m_thermo->setState_UV(u/mass,m_vol/mass, 1.0e-7);        temp = mix.temperature(); //mix.setTemperature(temp);    }    //m_state[0] = temp;    size_t loc = m_nsp + 2;    SurfPhase* surf;    for (size_t m = 0; m < m_nwalls; m++) {        surf = m_wall[m]->surface(m_lr[m]);        if (surf) {            //                surf->setTemperature(temp);            //surf->setCoverages(y+loc);            m_wall[m]->setCoverages(m_lr[m], y+loc);            loc += surf->nSpecies();        }    }    // save parameters needed by other connected reactors    m_enthalpy = m_thermo->enthalpy_mass();    m_pressure = m_thermo->pressure();    m_intEnergy = m_thermo->intEnergy_mass();    m_thermo->saveState(m_state);}

void LatticeSolidPhase::_updateThermo() const{    doublereal tnow = temperature();    if (m_tlast != tnow) {        getMoleFractions(DATA_PTR(m_x));        size_t strt = 0;        for (size_t n = 0; n < m_nlattice; n++) {            m_lattice[n]->setTemperature(tnow);            m_lattice[n]->setMoleFractions(DATA_PTR(m_x) + strt);            m_lattice[n]->setPressure(m_press);            strt += m_lattice[n]->nSpecies();        }        m_tlast = tnow;    }}

RealIdealGasFluidProperties::g(Real v, Real e) const{  // g(p,T) for SGEOS is given by Equation (37) in the following reference:  //  // Ray A. Berry, Richard Saurel, Olivier LeMetayer  // The discrete equation method (DEM) for fully compressible, two-phase flows in  //   ducts of spatially varying cross-section  // Nuclear Engineering and Design 240 (2010) p. 3797-3818  //  const Real p = pressure(v, e);  const Real T = temperature(v, e);  return _gamma * _cv * T - _cv * T * std::log(std::pow(T, _gamma) / std::pow(p, _gamma - 1.0));}

void WaterSSTP::setPressure(doublereal p){    double T = temperature();    double dens = density();    int waterState = WATER_GAS;    double rc = m_sub.Rhocrit();    if (dens > rc) {        waterState = WATER_LIQUID;    }    doublereal dd = m_sub.density(T, p, waterState, dens);    if (dd <= 0.0) {        throw CanteraError("setPressure", "error");    }    setDensity(dd);}

void MaskellSolidSolnPhase::_updateThermo() const{    assert(m_kk == 2);    static const int cacheId = m_cache.getId();    CachedScalar cached = m_cache.getScalar(cacheId);    // Update the thermodynamic functions of the reference state.    doublereal tnow = temperature();    if (!cached.validate(tnow)) {        m_spthermo->update(tnow, m_cp0_R.data(), m_h0_RT.data(), m_s0_R.data());        for (size_t k = 0; k < m_kk; k++) {            m_g0_RT[k] = m_h0_RT[k] - m_s0_R[k];        }    }}

void RedlichKisterVPSSTP::s_update_lnActCoeff() const{    doublereal T = temperature();    lnActCoeff_Scaled_.assign(m_kk, 0.0);    /*     *  Scaling:  I moved the division of RT higher so that we are always dealing with G/RT dimensionless terms     *            within the routine. There is a severe problem with roundoff error in these calculations. The     *            dimensionless terms help.     */    for (size_t i = 0; i < numBinaryInteractions_; i++) {        size_t iA = m_pSpecies_A_ij[i];        size_t iB = m_pSpecies_B_ij[i];        double XA = moleFractions_[iA];        double XB = moleFractions_[iB];        doublereal deltaX = XA - XB;        size_t N = m_N_ij[i];        vector_fp& he_vec = m_HE_m_ij[i];        vector_fp& se_vec = m_SE_m_ij[i];        doublereal poly = 1.0;        doublereal polyMm1 = 1.0;        doublereal sum = 0.0;        doublereal sumMm1 = 0.0;        doublereal sum2 = 0.0;        for (size_t m = 0; m < N; m++) {            doublereal A_ge = (he_vec[m] - T * se_vec[m]) / (GasConstant * T);            sum += A_ge * poly;            sum2 += A_ge * (m + 1) * poly;            poly *= deltaX;            if (m >= 1) {                sumMm1 += (A_ge * polyMm1 * m);                polyMm1 *= deltaX;            }        }        doublereal oneMXA = 1.0 - XA;        doublereal oneMXB = 1.0 - XB;        for (size_t k = 0; k < m_kk; k++) {            if (iA == k) {                lnActCoeff_Scaled_[k] += (oneMXA * XB * sum) + (XA * XB * sumMm1 * (oneMXA + XB));            } else if (iB == k) {                lnActCoeff_Scaled_[k] += (oneMXB * XA * sum) + (XA * XB * sumMm1 * (-oneMXB - XA));            } else {                lnActCoeff_Scaled_[k] += -(XA * XB * sum2);            }        }        // Debug against formula in literature    }}

void DiffusionCoefficient<EvalT, Traits>::evaluateFields(typename Traits::EvalData workset){  // Diffusion Coefficient  for (std::size_t cell=0; cell < workset.numCells; ++cell) {    for (std::size_t qp=0; qp < numQPs; ++qp) {        	diffusionCoefficient(cell,qp) = Dpre(cell,qp)*        			                                          std::exp(-1.0*Qdiff(cell,qp)/        			                                         Rideal/temperature(cell,qp));    }  }}

doublereal WaterSSTP::dthermalExpansionCoeffdT() const{    doublereal pres = pressure();    doublereal dens_save = density();    double T = temperature();    double tt = T - 0.04;    doublereal dd = m_sub.density(tt, pres, WATER_LIQUID, dens_save);    if (dd < 0.0) {        throw CanteraError("WaterSSTP::dthermalExpansionCoeffdT",            "Unable to solve for the density at T = {}, P = {}", tt, pres);    }    doublereal vald = m_sub.coeffThermExp();    m_sub.setState_TR(T, dens_save);    doublereal val2 = m_sub.coeffThermExp();    return (val2 - vald) / 0.04;}

  void LatticePhase::_updateThermo() const {    doublereal tnow = temperature();    if (fabs(molarDensity() - m_molar_density)/m_molar_density > 0.0001) {      throw CanteraError("_updateThermo","molar density changed from "			 +fp2str(m_molar_density)+" to "+fp2str(molarDensity()));    }    if (m_tlast != tnow) {      m_spthermo->update(tnow, &m_cp0_R[0], &m_h0_RT[0], 			 &m_s0_R[0]);      m_tlast = tnow;      for (size_t k = 0; k < m_kk; k++) {	m_g0_RT[k] = m_h0_RT[k] - m_s0_R[k];      }      m_tlast = tnow;    }  }

Func for_each_dim(Func func){	func(angle());	func(solid_angle());	func(length());	func(mass());	func(time());	func(temperature());	func(electric_current());	func(number_of_cycles());	func(number_of_decays());	func(luminous_intensity());	func(amount_of_substance());	func(amount_of_information());	return std::move(func);}

void SurfPhase::_updateThermo(bool force) const{    doublereal tnow = temperature();    if (m_tlast != tnow || force) {        m_spthermo->update(tnow, DATA_PTR(m_cp0), DATA_PTR(m_h0),                           DATA_PTR(m_s0));        m_tlast = tnow;        doublereal rt = GasConstant * tnow;        for (size_t k = 0; k < m_kk; k++) {            m_h0[k] *= rt;            m_s0[k] *= GasConstant;            m_cp0[k] *= GasConstant;            m_mu0[k] = m_h0[k] - tnow*m_s0[k];        }        m_tlast = tnow;    }}

void MixedSolventElectrolyte::s_update_dlnActCoeff_dlnN() const{    double T = temperature();    double RT = GasConstant*T;    dlnActCoeffdlnN_.zero();    /*     *  Loop over the activity coefficient gamma_k     */    for (size_t iK = 0; iK < m_kk; iK++) {        for (size_t iM = 0; iM < m_kk; iM++) {            double XM = moleFractions_[iM];            for (size_t i = 0; i <  numBinaryInteractions_; i++) {                size_t iA =  m_pSpecies_A_ij[i];                size_t iB =  m_pSpecies_B_ij[i];                double delAK = 0.0;                double delBK = 0.0;                double delAM = 0.0;                double delBM = 0.0;                if (iA==iK) {                    delAK = 1.0;                } else if (iB==iK) {                    delBK = 1.0;                }                if (iA==iM) {                    delAM = 1.0;                } else if (iB==iM) {                    delBM = 1.0;                }                double XA = moleFractions_[iA];                double XB = moleFractions_[iB];                double g0 = (m_HE_b_ij[i] - T * m_SE_b_ij[i]) / RT;                double g1 = (m_HE_c_ij[i] - T * m_SE_c_ij[i]) / RT;                dlnActCoeffdlnN_(iK,iM) += g0*((delAM-XA)*(delBK-XB)+(delAK-XA)*(delBM-XB));                dlnActCoeffdlnN_(iK,iM) += 2*g1*((delAM-XA)*(delBK-XB)*XB+(delAK-XA)*(delBM-XB)*XB+(delBM-XB)*(delBK-XB)*XA);            }            dlnActCoeffdlnN_(iK,iM) = XM*dlnActCoeffdlnN_(iK,iM);        }    }}

  void SingleSpeciesTP::setState_UV(doublereal u, doublereal v, 				    doublereal tol) {    doublereal dt;    setDensity(1.0/v);    for (int n = 0; n < 50; n++) {      dt = (u - intEnergy_mass())/cv_mass();      if (dt > 100.0) dt = 100.0;      else if (dt < -100.0) dt = -100.0;      setTemperature(temperature() + dt);      if (fabs(dt) < tol) {	return;      }    }    throw CanteraError("setState_UV",		       "no convergence. dt = " + fp2str(dt)+"/n"		       +"u = "+fp2str(u)+" v = "+fp2str(v)+"/n");  }

wxString grib_pi::GetLongDescription(){      return _("GRIB PlugIn for OpenCPN/n/Provides basic GRIB file overlay capabilities for several GRIB file types/n/and a request function to get GRIB files by eMail./n/n/Supported GRIB data include:/n/- wind direction and speed (at 10 m)/n/- wind gust/n/- surface pressure/n/- rainfall/n/- cloud cover/n/- significant wave height and direction/n/- air surface temperature (at 2 m)/n/- sea surface temperature/n/- surface current direction and speed/n/- Convective Available Potential Energy (CAPE)/n/- wind, altitude, temperature and relative humidity at 300, 500, 700, 850 hPa." );}