In This Package:

Calibration.cc

Go to the documentation of this file.

#include "Conventions/Calibration.h"

#include <cctype>
#include <string>
#include <cmath>
#include <sstream>
using namespace std;
using namespace DayaBay::Calibration;


static const char* sourceNames[] = {
    "Unknown",
    "LED",
    "Germanium_68",
    "Americium_Carbon_Cobalt_60",
    0
};
static int kSourceNames = 4;

static const char* locationNames[] = {
    "Unknown",
    "ACU_A_Center",
    "ACU_B_GdlsEdge",
    "ACU_C_GammaCatcher",
    "AD_WallUpper",
    "AD_WallCenter",
    "AD_WallLower",
    0
};
static int kLocationNames = 7;

const char* SourceType::AsString(SourceType_t id)
{

    if (id < 0 || id > kSourceNames) return sourceNames[0];
    return sourceNames[id];
}

SourceType::SourceType_t SourceType::FromString(const char* str)
{
    string s = str;

    for (int ind=1; sourceNames[ind]; ++ind) {
      if (s == sourceNames[ind]) return (SourceType::SourceType_t)(ind);
    }
    return kUnknown;
}

const char* Location::AsString(Location_t id)
{

    if (id < 0 || id > kLocationNames) return locationNames[0];
    return locationNames[id];
}

Location::Location_t Location::FromString(const char* str)
{
    string s = str;

    for (int ind=1; locationNames[ind]; ++ind) {
      if (s == locationNames[ind]) return (Location::Location_t)(ind);
    }
    return kUnknown;
}


DayaBay::CalibSourceId::CalibSourceId(SourceType::SourceType_t type,
                                      Location::Location_t location,
                                      Site::Site_t site,
                                      DetectorId::DetectorId_t det)
  : Detector(site,det)
{
  m_data += (0x000000ff & type) | (0x000000ff & location)<<8;
}

DayaBay::CalibSourceId::CalibSourceId(const std::string& name)
{
  short int siteDetId = DayaBay::Detector::siteDetPackedFromString(name); 
  Location::Location_t location = Location::kUnknown;
  SourceType::SourceType_t type = SourceType::kUnknown;
  
  // Find location
  for(int id=0; id<kLocationNames; id++){
    if( name.find(locationNames[id]) != std::string::npos ) 
      location=Location::FromString(locationNames[id]);
  }
  // Find Source Type
  for(int id=0; id<kSourceNames; id++){
    if( name.find(sourceNames[id]) != std::string::npos ) 
      type=SourceType::FromString(sourceNames[id]);
  }
  m_data = (siteDetId << 16) | (0x000000ff & location)<<8 | (0x000000ff & type);
}

DayaBay::CalibSourceId::~CalibSourceId() {}


SourceType::SourceType_t DayaBay::CalibSourceId::type() const
{
  return SourceType::SourceType_t(m_data & 0x000000ff);
}

Location::Location_t DayaBay::CalibSourceId::location() const
{
  return Location::Location_t((m_data & 0x0000ff00)>>8);
}

bool DayaBay::CalibSourceId::isWallMounted() const
{
  return (location() == Location::kAdWallUpper
          || location() == Location::kAdWallCenter
          || location() == Location::kAdWallLower);
}

string DayaBay::CalibSourceId::name() const
{
  ostringstream name;
  name << this->detName()
       << "_" << Location::AsString(this->location())
       << "_" << SourceType::AsString(this->type());
  return name.str();
}

double DayaBay::CalibSourceId::nominalX() const
{
  // Nominal calibration source X position
  switch (this->location()) {
  case Location::kAcuA_Center:
    return AD_AxisA_r * cos( AD_AxisA_phi );
  case Location::kAcuB_GdlsEdge:
    return AD_AxisB_r * cos( AD_AxisB_phi );
  case Location::kAcuC_GammaCatcher:
    return AD_AxisC_r * cos( AD_AxisC_phi );
  case Location::kAdWallUpper:
  case Location::kAdWallCenter:
  case Location::kAdWallLower:
    return AD_Wall_r * cos( AD_Wall_phi );
  default:
    return 0.0;
  }
}

double DayaBay::CalibSourceId::nominalY() const
{
  // Nominal calibration source Y position
  switch (this->location()) {
  case Location::kAcuA_Center:
    return AD_AxisA_r * sin( AD_AxisA_phi );
  case Location::kAcuB_GdlsEdge:
    return AD_AxisB_r * sin( AD_AxisB_phi );
  case Location::kAcuC_GammaCatcher:
    return AD_AxisC_r * sin( AD_AxisC_phi );
  case Location::kAdWallUpper:
  case Location::kAdWallCenter:
  case Location::kAdWallLower:
    return AD_Wall_r * sin( AD_Wall_phi );
  default:
    return 0.0;
  }
}

double DayaBay::CalibSourceId::nominalZ() const
{
  // Nominal calibration source Z position
  switch (this->location()) {
  case Location::kAdWallUpper:
    return AD_WallUpper_z;
  case Location::kAdWallCenter:
    return AD_WallCenter_z;
  case Location::kAdWallLower:
    return AD_WallLower_z;
  default:
    return 0.0;
  }
}

std::ostream& DayaBay::operator<<(std::ostream& str, 
                                  const DayaBay::CalibSourceId& sourceId)
{
  return str << sourceId.name();
}

---