conv.h

Go to the documentation of this file.

/* This file is part of Cloudy and is copyright (C)1978-2022 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 );

bool ConvInitSolution();

int ConvPresTempEdenIoniz(void);

int ConvTempEdenIoniz(void);

int ConvEdenIoniz(void);
 
int ConvIoniz(void);

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[] );

int ConvBase(long loopi);

int eden_sum(void);

void EdenChange( double EdenNew );

class ConvergenceCounter;

struct t_conv : public module {

        const char *chName() const
        {
                return "conv";
        }
        void zero();
        void comment(t_warnings&) {}

        char chConvEden[INPUT_LINE_LENGTH];

private:
        char m_chConvIoniz[INPUT_LINE_LENGTH];

public:
        void resetConvIoniz()
        {
                m_lgConvIoniz = true;
                strncpy(m_chConvIoniz, "NONE!!!!!", INPUT_LINE_LENGTH-1);
                m_BadConvIoniz[0] = 0.0;
                m_BadConvIoniz[1] = 0.0;
        }
        void setConvIonizFail(const char* reason, double oldval, double newval)
        {
                m_lgConvIoniz = false;
                strncpy(m_chConvIoniz, reason, INPUT_LINE_LENGTH-1);
                m_chConvIoniz[INPUT_LINE_LENGTH-1] = '\0';
                m_BadConvIoniz[0] = oldval;
                m_BadConvIoniz[1] = newval;
        }
        bool lgConvIoniz() const
        {
                return m_lgConvIoniz;
        }
        const char *chConvIoniz() const
        {
                return m_chConvIoniz;
        }
        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<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;
        }
        void resetCountersZone()
        {
                for( size_t i=0; i<m_counters_zone.size(); ++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];
        }
        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_ */