conv.h

Go to the documentation of this file.

/* This file is part of Cloudy and is copyright (C)1978-2025 by Gary J. Ferland and
 * others.  For conditions of distribution and use see copyright notice in license.txt */
 
#ifndef CONV_H_
#define CONV_H_

 
#include "module.h"

void ConvIterCheck();

void ConvInitSolution(double);

void ConvPresTempEdenIoniz();

void ConvTempEdenIoniz();

void ConvEdenIoniz();
 
void ConvIoniz();

void ConvFail(
        /* chMode is one of "pres", "eden", "ioni", "pops", "grai", "temp" */
        const char chMode[],
        /* chDetail - string giving details about the convergence failure */
        const char chDetail[] );

void ConvBase(long loopi);

void eden_sum();

void EdenChange( double EdenNew );
 
class ConvergenceCounter;

struct t_conv : public module {
 
        const char *chName() const
        {
                return "conv";
        }
        void zero();
        void comment(t_warnings&) {}
 
private:
        string m_chConvIoniz;
 
public:
        void resetConvIoniz()
        {
                m_lgConvIoniz = true;
                m_chConvIoniz = "NONE!!!!!";
                m_BadConvIoniz[0] = 0.0;
                m_BadConvIoniz[1] = 0.0;
        }
        void setConvIonizFail(const char* reason, double oldval, double newval)
        {
                m_lgConvIoniz = false;
                m_chConvIoniz = reason;
                m_BadConvIoniz[0] = oldval;
                m_BadConvIoniz[1] = newval;
        }
        bool lgConvIoniz() const
        {
                return m_lgConvIoniz;
        }
        const char *chConvIoniz() const
        {
                return m_chConvIoniz.c_str();
        }
        double convIonizOldVal() const
        {
                return m_BadConvIoniz[0];
        }
        double convIonizNewVal() const
        {
                return m_BadConvIoniz[1];
        }
 

        char chNotConverged[INPUT_LINE_LENGTH];
 
private:
        bool m_lgConvIoniz;
 
public:
        bool lgConvPops;
 
private:
        double m_BadConvIoniz[2];
 
public:
        long int nPres2Ioniz;

        bool lgFirstSweepThisZone;
        bool lgLastSweepThisZone;

        long int limPres2Ioniz;

        long int nTotalIoniz;

        long int nTotalIoniz_start;

        bool lgSearch;

        realnum AverEdenError;

        realnum BigHeatCoolError;
        realnum AverHeatCoolError;

        realnum BigPressError;
        realnum AverPressError;

        bool lgIonStageTrimed;

        bool lgOscilOTS;

        bool lgConvTemp;

        bool lgConvPres;

        bool lgConvEden;

        long int nTotalFailures;

        long int nTeFail;

        realnum failmx;

        long int nPreFail;

        long int nNeFail;

        realnum BigEdenError;

        long int nIonFail;

        long int nPopFail;

        long int nGrainFail;

        long int nChemFail;

        long int LimFail;

        bool lgMap;

        long int ifailz[12];

        char chSolverEden[20];

        char chSolverTemp[20];

        bool lgBadStop;

        bool lgAutoIt;

        bool lgAllTransitions;

        bool lgUpdateCouplings;

        realnum autocv;

        double EdenErrorAllowed;

        realnum PressureErrorAllowed;
 
        double MaxFractionalDensityStepPerIteration;

        realnum HeatCoolRelErrorAllowed;
 
        realnum IonizErrorAllowed;

        realnum GasPhaseAbundErrorAllowed;

        double dCmHdT;

        double sigma_dCmHdT;

        vector<double> hist_pres_density, hist_pres_current, hist_pres_error;
        long int hist_pres_nzone;

        vector<double> hist_temp_temp, hist_temp_heat, hist_temp_cool;
        long int hist_temp_nzone;
 
private:
        // Variables monitoring progress of convergence
        std::vector<long> m_counters;
        std::vector<long> m_counters_zone;
        std::vector<long> m_counters_max;
        std::vector<string> m_labels;
public:
        size_t ntypes(void) const
        {
                return m_counters.size();
        }
        ConvergenceCounter register_(const string name);
        void incrementCounter( const size_t type )
        {
                ++m_counters[type];
                ++m_counters_zone[type];
        }
        void resetCounters()
        {
                for( size_t i=0; i<m_counters.size(); ++i )
                {
                        m_counters[i] = 0;
                        m_counters_max[i] = 0;
                }
        }
        void resetCountersZone()
        {
                for( size_t i=0; i<m_counters_zone.size(); ++i )
                {
                        m_counters_max[i] = max(m_counters_max[i], m_counters_zone[i]);
                        m_counters_zone[i] = 0;
                }
        }
        long getCounter( const long type ) const
        {
                return m_counters[type];
        }
        long getCounter( const string& name ) const
        {
                for( size_t i=0; i<m_counters.size(); ++i )
                {
                        if (name == m_labels[i])
                                return m_counters[i];
                }
                return 0;
        }
        long getCounterZone( const long type ) const
        {
                return m_counters_zone[type];
        }
        long getCounterZone( const string& name ) const
        {
                for( size_t i=0; i<m_counters.size(); ++i )
                {
                        if (name == m_labels[i])
                                return m_counters_zone[i];
                }
                return 0;
        }
        long getCounterMax( const long type ) const
        {
                return m_counters_max[type];
        }
        long getCounterMax( const string& name ) const
        {
                for( size_t i=0; i<m_counters.size(); ++i )
                {
                        if (name == m_labels[i])
                                return m_counters_max[i];
                }
                return 0;
        }
        const char* getCounterName( const long type ) const
        {
                return m_labels[type].c_str();
        }
};
 
class ConvergenceCounter
{
        t_conv* m_conv;
        size_t m_type;
public:
   ConvergenceCounter(t_conv* convp, size_t type) 
                : m_conv(convp)
                , m_type(type)
        {}
        ConvergenceCounter& operator++(void)
        {
                m_conv->incrementCounter(m_type);
                return *this;
        }
};
 
extern t_conv conv;
 
#endif /* CONV_H_ */