cddrive.h

Go to the documentation of this file.

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

#ifndef CDDRIVE_H_
#define CDDRIVE_H_

class LineID;

void cdInit();

void cdTalk(bool);

void cdOutput( const string& filename = "", const char *mode = "w" );
void cdOutput( const string& filename, FILE* fp );

void cdInput( const string& filename = "", const char *mode = "r" );

void cdDepth_depth( double cdDepth[] );

long int cdnZone();

double cdB21cm();

int cdRead( const string& );

long debugLine( realnum wavelength );

void cdNoExec();

int cdDrive();


/* The next two routines confirm that the previous calculation was ok 
 * or produce a list of error conditions */

void cdErrors(FILE* );

void cdNwcns(
  long int *NumberWarnings, 
  long int *NumberCautions, 
  long int *NumberNotes, 
  long int *NumberSurprises, 
  long int *NumberTempFailures, 
  long int *NumberPresFailures,
  long int *NumberIonFailures, 
  long int *NumberNeFailures );

void cdReasonGeo(FILE*);

void cdWarnings(FILE*);
void cdCautions(FILE*);
void cdSurprises(FILE*);
void cdNotes(FILE*);

/***********************************************************
 *
 * The next routines examine the predictions of the previous model
 *
 ***********************************************************/

long int cdLine(const string& chLabel, 
                                realnum wavelength, 
                                double *relint, 
                                double *absint,
                                // 0 is intrinsic,
                                // 1 emergent
                                // 2 is intrinsic cumulative,
                                // 3 emergent cumulative
                                int LineType = 0 );

long int cdLine(
        const LineID& line,
        /* linear intensity relative to normalization line*/
        double *relint, 
        /* log of luminosity or intensity of line */
        double *absint ,
        // 0 is intrinsic,
        // 1 emergent
        // 2 is intrinsic cumulative,
        // 3 emergent cumulative
        int LineType = 0 );

void cdLine_ip(long int ipLine, 
                           double *relint, 
                           double *absint ,
                           // 0 is intrinsic,
                           // 1 emergent
                           // 2 is intrinsic cumulative,
                           // 3 emergent cumulative
                           int LineType = 0 );

int cdColm(const char*, long, double* );

double cdH2_colden( long iVib , long iRot );

void cdEmis(
        const char *chLabel,
        realnum wavelength, 
        double *emiss,
        bool lgEmergent );

void cdEmis(
        const LineID& line,
        double *emiss,
        bool lgEmergent );

void cdEmis_ip(
        long int ipLine, 
        double *emiss ,
        bool lgEmergent);

double cdCooling_last();

double cdHeating_last();

double cdEDEN_last();

void cdPressure_last(
        double *TotalPressure,
        double *GasPressure,
        double *RadiationPressure);

void cdPressure_depth(
        double TotalPressure[],
        double GasPressure[],
        double RadiationPressure[]);

double cdTemp_last();

int cdIonFrac(
        const char *chLabel, 
        long int IonStage, 
        double *fracin, 
        const char *chWeight ,
        bool lgDensity );

void cdVersion(char chString[] );

void cdDate(char chString[] );

/* The following pairs of routines can keep track of the execution time for one model -
 * cdSetExecTime called first (in cdInit, not by the user) to initialize timer.
 * When cdExecTime is called it will return the elapsed time in seconds
 * since cdInit called cdSetExecTime*/

void cdSetExecTime();

double cdExecTime();

long int cdGetLineList(
        const string& chFile,
        vector<LineID>& lineids);

void cdTimescales(
        double *TTherm , 
        double *THRecom , 
        double *TH2 );

void cdSPEC2( 
        int Option,
        realnum ReturnedSpectrum[] );

int cdTemp(
        const char *chLabel, 
        long int IonStage, 
        double *TeMean, 
        const char *chWeight );

int cdTemp(
        const string &chLabel, 
        double *TeMean, 
        const char *chWeight );

void test_cdTemp_molecules();


void cdPrintCommands( FILE * );

void cdClosePunchFiles();

long int cdH2_Line(
          /* indices for the upper level */
          long int iElecHi, 
          long int iVibHi ,
          long int iRotHi ,
          /* indices for lower level */
          long int iElecLo, 
          long int iVibLo ,
          long int iRotLo ,
          /* linear intensity relative to normalization line*/
          double *relint, 
          /* log of luminosity or intensity of line */
          double *absint );

// Maximum memory used for the current process (in kB)
long cdMemory();

/* none of the following are generally needed */

extern bool lgcdInitCalled;

#endif /* CDDRIVE_H_ */