rl_Multilayer_rdb.cc

// File:   rl_Multilayer_rdb.cc
// Author: Terry Gaetz

// --8<--8<--8<--8<--
//
// Copyright (C) 2006 Smithsonian Astrophysical Observatory
//
// This file is part of rl_ray
//
// rl_ray is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// rl_ray is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the 
//       Free Software Foundation, Inc. 
//       51 Franklin Street, Fifth Floor
//       Boston, MA  02110-1301, USA
//
// -->8-->8-->8-->8--

#include <rl_Multilayer_rdb.h>              // rl_Multilayer_rdb

#include <rl_raylib/rl_Traits.h>
#include <rl_DielectricPOD_rdb.h>           // rl_DielectricPOD_rdb
#include <tracefct/exiterrvals.h>
#include <tracefctxx/TraceFct.h>

#include <cctype>                           // toupper


#include <mst_rdb/mst_rdb.h>
#include <suplib/str.h>

//=========================================================================
// statics

static TokListToken      /* note:  must be in lexical order */
srough_type[] =
{
  { "DW_CSAO",    rl_Traits::ERoughDebyeWaller_CSAO    },
  { "DW_RSAO",    rl_Traits::ERoughDebyeWaller_RSAO    },
  { "DW_SPILLER", rl_Traits::ERoughDebyeWaller_Spiller },
  { "MDW",        rl_Traits::ERoughModifiedDebyeWaller },
  { "NC",         rl_Traits::ERoughNevotCroce          },
  { "NONE",       rl_Traits::ERoughNone                }
};
TokList srough_types = GenTokList( srough_type );

//=========================================================================
// dtor, ctors

rl_Multilayer_rdb::
~rl_Multilayer_rdb()
{}

//-------------------------------------------------------------------------
// Routine to set up surface data

rl_Multilayer_rdb::
rl_Multilayer_rdb( char const             rdb_filename[], 
                   rl_Traits::EInterpMode interp_mode 
                 )
  : rl_Multilayer(0,0)
{
  init_from_rdb( rdb_filename, interp_mode );
}

//-------------------------------------------------------------------------
// function to read in data from multilayer rdb table

void rl_Multilayer_rdb::
init_from_rdb( char const             *rdb_filename_in, 
               rl_Traits::EInterpMode interp_mode 
             )
{
  TraceFct tf("rl_Multilayer_rdb::init");

  own_data_ = rl_Traits::True;

  FILE             *in;
  rdbHeader        *hdr;
  DataColumnMap_st *map;

  long int          nrow;
  int               num_fields = 0;

  typedef struct LayerRecord
  {
    char*  material;
    double thickness;
    double bulkdensity;
    char*  roughness_type;
    double srough;
    char*  optconst_rdb;
  } LayerRecord;
  LayerRecord layer_record;

  RDBFieldStInfo fields[6];
#if 0
  {
    RDBentry( material,       RDB_String, LayerRecord ),
    RDBentry( thickness,      RDB_Num,    LayerRecord ),
    RDBentry( bulkdensity,    RDB_Num,    LayerRecord ),
    RDBentry( optconst_rdb,   RDB_String, LayerRecord ),
    RDBentry( roughness_type, RDB_String, LayerRecord ),
    RDBentry( srough,         RDB_Num,    LayerRecord )
  };
#endif

  #define SET_FIELD(colname,var,vartype,idx)             \
  do{                                                    \
      fields[idx].name = #colname;                       \
      fields[idx].type = vartype;                        \
      fields[idx].offset = offsetof( LayerRecord, var ); \
      idx++;                                             \
  }while(0)

  #define CHECK_FIELD(colname) \
  if (! rdb_is_column( hdr, #colname ) ) \
  {                        \
    tf.die( "no \"" #colname "\"column in reflectance rdb file" ); \
  }

  int error;
  char *rdb_filename =
    str_interp( rdb_filename_in, 1, NULL, NULL, &error );
  if ( error )
    tf.die( "error interpolating filename: %s", rdb_filename_in );

  if ( !(in=fopen( rdb_filename, "r" )) )
    tf.exit( ExitERR_fopen, "unable to open input `%s'", rdb_filename );

  if (! (hdr = rdb_rd_hdr( in )) )
    tf.die( "rdb file `%s' contains no rdb headers!", rdb_filename );

  CHECK_FIELD( material );
  SET_FIELD( material, material, RDB_String, num_fields );

  CHECK_FIELD( thickness );
  SET_FIELD( thickness, thickness, RDB_Num, num_fields );

  CHECK_FIELD( bulkdensity );
  SET_FIELD( bulkdensity, bulkdensity, RDB_Num, num_fields );

  CHECK_FIELD( optconst_rdb );
  SET_FIELD( optconst_rdb, optconst_rdb, RDB_String, num_fields );

  int have_roughness = 0;
  if ( rdb_is_column( hdr, "roughness_type" ) )
  {
    have_roughness = 1;

    CHECK_FIELD( srough );
    SET_FIELD( roughness_type, roughness_type, RDB_String, num_fields );
    SET_FIELD( srough,         srough,         RDB_Num,    num_fields );
  }

  map = rdb_map_cols_stst( hdr, num_fields, fields );

  /*
   * count number of rows (excluding header & comments) in rdb file
   */
  nrow = rdb_count(in, hdr);
  if ( nrow < 0 )
    tf.die( "multilayer rdb file '%s' is not rewindable" );
  else if ( nrow == 0 )
    tf.die(
      "multilayer rdb file '%s' must have at least one row", rdb_filename );

  num_layers_ = nrow;

  layer_ = new rl_DielectricLayer[num_layers_];
  if (! layer_ )
  {
    tf.exit(ExitERR_alloc, "unable to allocate rl_DielectricLayer array" );
  }

  int n;
  for ( n = 0 ; n < num_layers_ ; ++n )
  {
    rdb_col_read_st(in, hdr, map, &layer_record);
    if (! (layer_record.bulkdensity >= 0.0) )
    {
      tf.die( "layer %d:  must have bulk density >= 0.0" );
    }
    rl_DielectricPOD_rdb diel( layer_record.optconst_rdb );

    double srough = 0.0;
    rl_Traits::ERoughType rtype = rl_Traits::ERoughNone;

    if ( have_roughness )
    {
      char* str = layer_record.roughness_type;
      while ( *str )
      {
        *str = toupper(*str);
        ++str;
      }
      int roughtype = tokmatch( layer_record.roughness_type, &srough_types );

      if ( roughtype >= 0 )
      {
        rtype = (rl_Traits::ERoughType)roughtype;
      }
      else
      {
        tf.die( "invalid \"roughness\" type %s", layer_record.roughness_type );
      }
      srough = layer_record.srough;
    }

    rl_Traits::Bool substrate = rl_Traits::Bool((n == num_layers_-1) ? 1 : 0);

    layer_[n].init( diel.const_data_ptr(),
                    diel.num_elts(),
                    layer_record.thickness,
                    srough,
                    rtype,
                    interp_mode,
                    layer_record.bulkdensity,
                    layer_record.material,
                    substrate );

    delete layer_record.material;
    delete layer_record.roughness_type;
    delete layer_record.optconst_rdb;
  }
  // clean up

  free( rdb_filename );
  rdb_free_map(map);       // free up data column map
  rdb_free_hdr(hdr);       // free up rdbHeader dynamic allocation
  fclose(in);
}
#undef SET_FIELD
#undef CHECK_FIELD