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_ */