AttSlice.cc

Go to the documentation of this file.

#include <atm/AttSlice.h>
#include <utl/AugerUnits.h>

#include <iostream>

using namespace std;
using namespace atm;
using namespace utl;


AttSlice::AttSlice(const std::string& headerDBName,
                   const std::string& sliceId,
                   const std::string& aerosolZoneId,
                   const double minH,
                   const double maxH) :
  VZoneSlice(headerDBName, sliceId, aerosolZoneId, minH, maxH),
  fAttAlpha(0),
  fMinAttAlpha(0),
  fMaxAttAlpha(0),
  fMinAttAlphaCor(0),
  fMaxAttAlphaCor(0),
  fMinAttAlphaUncor(0),
  fMaxAttAlphaUncor(0),
  fAttLambda(0),
  fMinAttLambda(0),
  fMaxAttLambda(0),
  fVAOD(0),
  fMinVAOD(0),
  fMaxVAOD(0),
  fMinVAODCor(0),
  fMaxVAODCor(0),
  fMinVAODUncor(0),
  fMaxVAODUncor(0)
{
}


double
AttSlice::GetAttAlpha()
  const
{
  if (!fAttAlpha)
    GetSliceData(fAttAlpha, "attenuation", "att_alpha", "reciprocal attenuation length");

  return (*fAttAlpha)*(1./meter);
}


double
AttSlice::GetMinAttAlpha()
  const
{
  if (!fMinAttAlpha)
    GetSliceData(fMinAttAlpha, "attenuation", "min_att_alpha", "attenuation length error");

  return (*fMinAttAlpha)*(1./meter);
}


double
AttSlice::GetMinAttAlphaCor()
  const
{
  if (!fMinAttAlphaCor)
    GetSliceData(fMinAttAlphaCor, "attenuation", "min_alpha_cor", "correlated attenuation length error");

  return (*fMinAttAlphaCor)*(1./meter);
}


double
AttSlice::GetMinAttAlphaUncor()
  const
{
  if (!fMinAttAlphaUncor)
    GetSliceData(fMinAttAlphaUncor, "attenuation", "min_alpha_uncor", "uncorrelated attenuation length error");

  return (*fMinAttAlphaUncor)*(1./meter);
}


double
AttSlice::GetMaxAttAlpha()
  const
{
  if (!fMaxAttAlpha)
    GetSliceData(fMaxAttAlpha, "attenuation", "max_att_alpha", "attenuation length error");

  return (*fMaxAttAlpha)*(1./meter);
}


double
AttSlice::GetMaxAttAlphaCor()
  const
{
  if (!fMaxAttAlphaCor)
    GetSliceData(fMaxAttAlphaCor, "attenuation", "max_alpha_cor", "correlated attenuation length error");

  return (*fMaxAttAlphaCor)*(1./meter);
}


double
AttSlice::GetMaxAttAlphaUncor()
  const
{
  if (!fMaxAttAlphaUncor)
    GetSliceData(fMaxAttAlphaUncor, "attenuation", "max_alpha_uncor", "uncorrelated attenuation length error");

  return (*fMaxAttAlphaUncor)*(1./meter);
}


double
AttSlice::GetAttLambda()
  const
{
  if (!fAttLambda)
    GetLambdaSliceData(fAttLambda,
                       "attenuation", "attenuation_lambda_id",
                       "attenuation_lambda", "att_lambda",
                       "attenuation length lambda dependence");

  return *fAttLambda;
}


double
AttSlice::GetMinAttLambda()
  const
{
  if (!fMinAttLambda)
    GetLambdaSliceData(fMinAttLambda,
                       "attenuation", "attenuation_lambda_id",
                       "attenuation_lambda", "min_att_lambda",
                       "min value of attenuation length lambda dependence");

  return *fMinAttLambda;
}


double
AttSlice::GetMaxAttLambda()
  const
{
  if (!fMaxAttLambda)
    GetLambdaSliceData(fMaxAttLambda,
                       "attenuation", "attenuation_lambda_id",
                       "attenuation_lambda", "max_att_lambda",
                       "max value of attenuation length lambda dependence");

  return *fMaxAttLambda;
}


double
AttSlice::GetVAOD()
  const
{
  if (!fVAOD)
    GetSliceData(fVAOD, "attenuation", "VAOD", "VAOD");

  return (*fVAOD);
}


double
AttSlice::GetMinVAOD()
  const
{
  if (!fMinVAOD)
    GetSliceData(fMinVAOD, "attenuation", "min_VAOD", "minimum value of VAOD");

  return (*fMinVAOD);
}


double
AttSlice::GetMinVAODCor()
  const
{
  if (!fMinVAODCor)
    GetSliceData(fMinVAODCor, "attenuation", "min_VAOD_cor", "minimum value of correlated VAOD uncertainty");

  return (*fMinVAODCor);
}


double
AttSlice::GetMinVAODUncor()
  const
{
  if (!fMinVAODUncor)
    GetSliceData(fMinVAODUncor, "attenuation", "min_VAOD_uncor", "minimum value of uncorrelated VAOD uncertainty");

  return (*fMinVAODUncor);
}


double
AttSlice::GetMaxVAOD()
  const
{
  if (!fMaxVAOD)
    GetSliceData(fMaxVAOD, "attenuation", "max_VAOD", "maximum value of VAOD");

  return (*fMaxVAOD);
}


double
AttSlice::GetMaxVAODCor()
  const
{
  if (!fMaxVAODCor)
    GetSliceData(fMaxVAODCor, "attenuation", "max_VAOD_cor", "maximum value of correlated VAOD uncertainty");

  return (*fMaxVAODCor);
}

double
AttSlice::GetMaxVAODUncor()
  const
{
  if (!fMaxVAODUncor)
    GetSliceData(fMaxVAODUncor, "attenuation", "max_VAOD_uncor", "maximum value of uncorrelated VAOD uncertainty");

  return (*fMaxVAODUncor);
}


AttSlice::~AttSlice()
{
  delete fAttAlpha;
  delete fMinAttAlpha;
  delete fMaxAttAlpha;
  delete fMinAttAlphaCor;
  delete fMaxAttAlphaCor;
  delete fMinAttAlphaUncor;
  delete fMaxAttAlphaUncor;
  delete fAttLambda;
  delete fMinAttLambda;
  delete fMaxAttLambda;
  delete fVAOD;
  delete fMinVAOD;
  delete fMaxVAOD;
  delete fMinVAODCor;
  delete fMaxVAODCor;
  delete fMinVAODUncor;
  delete fMaxVAODUncor;
}


// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// compile-command: "make -C .. -k"
// End: