#
# Testing functionality (meeting format requirements, etc.) of basic atmospheric
#  scenario data.
#
# General test setup: reading in raw data, regridding to common p-grid (1D),
#  executing standard pre-RT calc internal test method atmfields_checkedCalc.
#
#
# This case is for Mars and specifically tests
#
# (CASES 1-72)
#  - 72 Mars scenarions: 4seasons x 2daytimes x 3dustloads x 3solaractivities
#  - t, z, and all abs species vmr (the ones that follow the basename convention
#     are caught by abs_speciesDefineAllInScenario and AtmRawRead; others are
#     derived manually) in the case folder (no abs species in "unused/"
#     subfolder).
#  - regridding to a pressure grid taken from the read-in altitude grid
#
# Jana Mendrok 2013-02-26

Arts2 {
INCLUDE "general/general.arts"
INCLUDE "general/agendas.arts"
INCLUDE "general/planet_mars.arts"


# 1-dimensional atmosphere
AtmosphereSet1D

GriddedField3Create( gf3tmp )
StringCreate( caseext )
StringCreate( casefull )
StringCreate( atmcase )
IndexCreate( ncases )


# set basic case folder
StringCreate( basename )
StringSet( basename, "planets/Mars/MPS/" )

# Arrays with (sub)case names
ArrayOfStringCreate( seasoncasearray )
ArrayOfStringSet( seasoncasearray, ["Mars.Ls0", "Mars.Ls90", "Mars.Ls180", "Mars.Ls270"] )
ArrayOfStringCreate( timecasearray )
ArrayOfStringSet( timecasearray, [".day", ".night"] )
ArrayOfStringCreate( dustcasearray )
ArrayOfStringSet( dustcasearray, [".dust-high", ".dust-low", ".dust-medium"] )
ArrayOfStringCreate( solarcasearray )
ArrayOfStringSet( solarcasearray, [".sol-avg", ".sol-max", ".sol-min"] )



# we go with several nested foorloop through the different cases.
#  All those cases have identical abs species to process.
#  Order of agenda definitions has to be inverse from their execution (as we can
#  only copy an agenda AFTER we have defined it).

AgendaCreate( forloop_agenda_solar )
AgendaSet( forloop_agenda_solar ){
  # construct atmcase name IV (Mars.LsXX.YY.dust-ZZ.sol-WW)
  Extract( casefull, solarcasearray, forloop_index )
  Append( atmcase, casefull )
  Append( basename, atmcase )
  StringSet( caseext, "/" )
  Append( basename, caseext )
  Append( basename, atmcase )
  Print( basename, 0 )

  # derive absspecies with standard name from scenario
  abs_speciesDefineAllInScenario( basename=basename )
  #WriteXMLIndexed( "ascii", forloop_index,
  #                 abs_species, "TestAtmScen_Mars_allInScen.abs_species" )
  AtmRawRead( t_field_raw, z_field_raw, vmr_field_raw,
              abs_species, basename )

  # adding species or variants that do not follow the general naming convention
  abs_speciesAdd( species=["CH4"] )
  Copy( casefull, basename )
  StringSet( caseext, ".CH4_high" )
  Append( casefull, caseext )
  #Print( casefull, 0 )
  ReadXML( gf3tmp, casefull )
  Append( vmr_field_raw, gf3tmp )

  abs_speciesAdd( species=["H2O-162"] )
  Copy( casefull, basename )
  StringSet( caseext, ".H2O-162" )
  Append( casefull, caseext )
  #Print( casefull, 0 )
  ReadXML( gf3tmp, casefull )
  Append( vmr_field_raw, gf3tmp )

  # now derive common p_grid and regrid atm fields to this
  p_gridFromZRaw(	p_grid, z_field_raw, 0 )
  AtmFieldsCalc

  Extract( z_surface, z_field, 0 )

  atmfields_checkedCalc
  atmgeom_checkedCalc
  #WriteXML( "ascii", p_grid )
  #WriteXML( "ascii", z_field )
  #WriteXML( "ascii", t_field )
  #WriteXML( "ascii", vmr_field_raw )
  WriteXMLIndexed( "ascii", forloop_index, vmr_field )
}

AgendaCreate( forloop_agenda_dust )
AgendaSet( forloop_agenda_dust ){
  # construct atmcase name III (Mars.LsXX.YY.dust-ZZ)
  Extract( casefull, dustcasearray, forloop_index )
  Append( atmcase, casefull )
  # keep the casestring till dust and make upper-level folder name
  Append( basename, atmcase )
  StringSet( caseext, "/" )
  Append( basename, caseext )
  Copy( forloop_agenda, forloop_agenda_solar )
  nelemGet( ncases, solarcasearray )
  IndexStepDown( ncases, ncases )
  ForLoop( forloop_agenda, 0, ncases, 1 )
}

AgendaCreate( forloop_agenda_time )
AgendaSet( forloop_agenda_time ){
  # construct atmcase name II (Mars.LsXX.d/n)
  Extract( casefull, timecasearray, forloop_index )
  Append( atmcase, casefull )
  Copy( forloop_agenda, forloop_agenda_dust )
  nelemGet( ncases, dustcasearray )
  IndexStepDown( ncases, ncases )
  ForLoop( forloop_agenda, 0, ncases, 1 )
}

AgendaCreate( forloop_agenda_season )
AgendaSet( forloop_agenda_season ){
  # construct atmcase name I (Mars.LsXX)
  Extract( casefull, seasoncasearray, forloop_index )
  Copy( atmcase, casefull )
  Copy( forloop_agenda, forloop_agenda_time )
  nelemGet( ncases, timecasearray )
  IndexStepDown( ncases, ncases )
  ForLoop( forloop_agenda, 0, ncases, 1 )
}


nelemGet( ncases, seasoncasearray )
IndexStepDown( ncases, ncases )
Copy( forloop_agenda, forloop_agenda_season )
ForLoop( forloop_agenda, 0, ncases, 1  )

}