conv.h

Go to the documentation of this file.

/* This file is part of Cloudy and is copyright (C)1978-2013 by Gary J. Ferland and
 * others.  For conditions of distribution and use see copyright notice in license.txt */
 
#ifndef CONV_H_
#define CONV_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 );
 
// Variables monitoring progress of convergence
enum counter_type
{
        MOLE_SOLVE, 
        MOLE_SOLVE_STEPS, 
        NEWTON, 
        NEWTON_LOOP,
        CONV_BASE_CALLS,
        CONV_BASE_LOOPS,
        CONV_BASE_ACCELS,
        ION_SOLVES,
        ISO_LOOPS,
        EDEN_CHANGES,
        TEMP_CHANGES,
        PRES_CHANGES,
        NTYPES
};
 
struct t_conv {
 
        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 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
        long m_counters[NTYPES];
        long m_counters_zone[NTYPES];
public:
        void incrementCounter( const counter_type type )
        {
                ++m_counters[type];
                ++m_counters_zone[type];
        }
        void resetCounters()
        {
                for( long i=0; i<NTYPES; ++i )
                        m_counters[i] = 0;
        }
        void resetCountersZone()
        {
                for( long i=0; i<NTYPES; ++i )
                        m_counters_zone[i] = 0;
        }
        long getCounter( const long type )
        {
                return m_counters[type];
        }
        long getCounterZone( const long type )
        {
                return m_counters_zone[type];
        }
};
 
 
extern t_conv conv;
 
#endif /* CONV_H_ */