abund.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 ABUND_H_
#define ABUND_H_

#include "module.h"

void AbundancesSet(void);

void AbundancesPrt( void );

class Parser;
void abund_starburst(Parser &p);

double AbundancesTable(double r0, 
  double depth, 
  long int iel);



typedef struct isotope
{
private:
        int     Niso;           /* Number of isotopes for element */
        vector<int>     Aiso;
        vector<realnum> abnd, mass, spin, magmom;

        /* Functions to access abundances */
        int getIsoInd (int Anum)
        {
                int j = -1;
                for( int i = 0; i < Niso; i++ )
                {
                        if( Aiso[i] == Anum )
                        {
                                j = i;
                                break;
                        }
                }
                return  j;
        }
public:
        void init ( )
        {
                Niso = 0;
                return;
        }
        int getNiso ( )
        {
                return  Niso;
        }
        void setData (int Anum, realnum nmass, realnum nspin, realnum nmagmom)
        {
                Aiso.push_back( Anum );
                abnd.push_back( realnum( 0. ) );
                mass.push_back( nmass );
                spin.push_back( nspin );
                magmom.push_back( nmagmom );
                Niso++;
        }
        int getAiso (int iso)
        {
                int Aval = -1;
                if( iso >= 0 && iso < Niso )
                        Aval = Aiso[iso];
                return  Aval;
        }
        realnum getMass (int Anum)
        {
                realnum nmass = -1.0;
                int j = getIsoInd( Anum );
                if( j != -1 )
                        nmass = mass[j];
                return  nmass;
        }
        realnum getSpin (int Anum)
        {
                realnum nspin = -1.0;
                if( spin.size() == 0 )
                        return  nspin;
                int j = getIsoInd( Anum );
                if( j != -1 )
                        nspin = spin[j];
                return  nspin;
        }
        realnum getMagMom (int Anum)
        {
                realnum nmagmom = -1.0;
                if( magmom.size() == 0 )
                        return  nmagmom;
                int j = getIsoInd( Anum );
                if( j != -1 )
                        nmagmom = magmom[j];
                return  nmagmom;
        }
        int setAbn (int Anum, realnum abn)
        {
                int j = getIsoInd( Anum );
                if( j != -1 )
                        abnd[j] = abn;
                return  j;
        }
        realnum getAbn (int Anum)
        {
                realnum abn = -1.0;
                int j = getIsoInd( Anum );
                if( j != -1 )
                        abn = abnd[j];
                return  abn;
        }
        /* Express all isotope fractions in terms of the most abundant isotope. */
        void normAbn ( )
        {
                realnum fracsum = 0.;
                for( int j = 0; j < Niso; j++ )
                {
                        fracsum += abnd[j];
                }

                fracsum = 1.0 / fracsum;
                for( int j = 0; j < Niso; j++ )
                {
                        abnd[j] *= fracsum;
                }
                return;
        }
        bool isAnyIllegal (void)
        {
                bool isZero = false;
                for( int j = 0; j < Niso; j++ )
                {
                        if( abnd[j] < 0.0 )
                        {
                                isZero = true;
                                break;
                        }
                }
                return  isZero;
        }
        void prtIso (FILE *fp)
        {
                for( int j = 0; j < Niso; j++ )
                {
                        fprintf(fp, "%2d", Aiso[j]);
                        if( j != Niso-1 )
                                fprintf(fp, ", ");
                }
                fprintf(fp, "\n");
                return;
        }
        void prtIsoPairs (FILE *fp)
        {
                for( int j = 0; j < Niso; j++ )
                {
                        fprintf(fp, "  (%2d, %.4e)", Aiso[j], abnd[j]);
                }
                fprintf(fp, "\n");
                return;
        }
        void rm_nuc_data ( )
        {
                spin.resize( 0 );
                magmom.resize( 0 );
                return;
        }
} t_isotope;



struct t_abund : public module {
        const char *chName() const
        {
                return "abund";
        }

        void zero();
        void comment(t_warnings&) {}
        bool lgAGN[LIMELM];

        realnum SolarSave[LIMELM];

        bool lgAbnSolar;

        bool lgAbundancesSet;

        realnum solar[LIMELM];

        /* isotope fractions */
        t_isotope IsoAbn[LIMELM];

        bool lgAbunTabl[LIMELM], 

          lgAbTaDepth[LIMELM], 

          lgAbTaON;

#       define  LIMTABD 500

        realnum AbTabFac[LIMTABD][LIMELM], 

          AbTabRad[LIMTABD][LIMELM];

        long int nAbunTabl;

        long int ipSolar[LIMELM], 
          npSolar;

        realnum ScaleElement[LIMELM];

        realnum Depletion[LIMELM], 

          depset[LIMELM];

        bool lgDepln;

        realnum ScaleMetals;

        };
extern t_abund abund;



#endif /* ABUND_H_ */