In This Package:

Detectors.cc

Go to the documentation of this file.

/* From Dan, for RPCs:

Here's the numbers you probably need:
        Near Sites:  54 panels
        Far Site:       81 panels
        Each panel has 4 layers.
        Each layer has 8 channels.
        Each channel gives 1 bit.

So according to your model, you'll have:

Bits:
| 3 | 2 | 7 | 8 | 8 |
Contents:
| channel  |  layer  |  panel  |  detector  |  site  |

*/

/* From Dan for AD calib pmts:

192:  top, target-viewing
193:  bottom, target-viewing
194:  top, gamma-catcher-viewing
195:  bottom, gamma-catcher-viewing
196:  top, mineral-oil-viewing
197:  bottom, mineral-oil-viewing

He counts from zero, so add +1 here
*/


#include "Conventions/Detectors.h"

#include <sstream>

// Detector

DayaBay::Detector::Detector(Site::Site_t site,
                            DetectorId::DetectorId_t det)
 : m_data(0)
{
    this->set(site,det);
}
DayaBay::Detector::Detector() : m_data(0) {}

DayaBay::Detector::~Detector() {}

void DayaBay::Detector::set(Site::Site_t site, DetectorId::DetectorId_t det)
{
    m_data = (site << 24) | (det << 16);
}


std::string DayaBay::Detector::asString() const
{
    std::stringstream ss;
    ss << *this; 
    return ss.str();
}

std::string DayaBay::Detector::detName() const
{
    std::string ret = Site::AsString(site());
    ret += DetectorId::AsString(detectorId());

    return ret;
}

DetectorId::DetectorId_t DayaBay::Detector::detectorId() const
{
    return (DetectorId::DetectorId_t)((m_data&0x00ff0000)>>16);
}

Site::Site_t DayaBay::Detector::site() const
{
    return (Site::Site_t)((m_data&0xff000000)>>24);
}

int DayaBay::Detector::fullPackedData() const
{
    return m_data;
}

short int DayaBay::Detector::siteDetPackedData() const
{
    return (short int)(m_data>>16);
}

bool DayaBay::Detector::bogus() const
{
    Site::Site_t site = this->site();
    DetectorId::DetectorId_t det = this->detectorId();

    return 
        // Only far site has AD #3 and #4
        ((site != Site::kFar)
         &&
         (det == DetectorId::kAD3 || det == DetectorId::kAD4))
        ||
        // Only near & far sites have known detectors
        ((site == Site::kMid || site == Site::kAberdeen)
         &&
         (det != DetectorId::kUnknown))
        ;
}

short int DayaBay::Detector::siteDetPackedFromString(const std::string str){
  DetectorId::DetectorId_t detId = DetectorId::FromString("Unknown");
  Site::Site_t site = Site::FromString("Unknown");
  
  //find site
  
  if (str.find("DayaBay")!=std::string::npos) site=Site::FromString("DayaBay");
  if (str.find("LingAo")!=std::string::npos) site=Site::FromString("LingAo");
  if (str.find("Mid")!=std::string::npos) site=Site::FromString("Mid");
  if (str.find("Far")!=std::string::npos) site=Site::FromString("Far");
  if (str.find("Aberdeen")!=std::string::npos) site=Site::FromString("Aberdeen");
  if (str.find("SAB")!=std::string::npos) site=Site::FromString("SAB");

  //find detector
  
  if (str.find("AD1")!=std::string::npos) detId=DetectorId::FromString("AD1");
  if (str.find("AD2")!=std::string::npos) detId=DetectorId::FromString("AD2");
  if (str.find("AD3")!=std::string::npos) detId=DetectorId::FromString("AD3");
  if (str.find("AD4")!=std::string::npos) detId=DetectorId::FromString("AD4");
  if (str.find("IWS")!=std::string::npos) detId=DetectorId::FromString("IWS");
  if (str.find("OWS")!=std::string::npos) detId=DetectorId::FromString("OWS");
  if (str.find("RPC")!=std::string::npos) detId=DetectorId::FromString("RPC");
  
  return DayaBay::Detector(site,detId).siteDetPackedData();
}


std::ostream& DayaBay::operator<<(std::ostream& str, const DayaBay::Detector& det)
{
    str << Site::AsString(det.site())
        << DetectorId::AsString(det.detectorId());
    if (det.bogus()) str << " IS BOGUS";
    return str;
}

bool DayaBay::operator<(const DayaBay::Detector& a, const DayaBay::Detector& b)
{
    return a.fullPackedData() < b.fullPackedData();
}

// DetectorSensor

DayaBay::DetectorSensor::DetectorSensor(unsigned int sensor_id,
                                        Site::Site_t site,
                                        DetectorId::DetectorId_t detid)
    : Detector(site,detid)
{
    m_data += 0x0000ffff&sensor_id;
}
DayaBay::DetectorSensor::~DetectorSensor() {}

int DayaBay::DetectorSensor::sensorId() const
{
    return m_data&0x0000ffff;
}
std::ostream& DayaBay::operator<<(std::ostream& str, const DayaBay::DetectorSensor& detsens)
{
    str << Site::AsString(detsens.site())
        << DetectorId::AsString(detsens.detectorId())
        << " 0x"<< std::hex << detsens.sensorId() << std::dec;
    if (detsens.bogus()) str << " IS BOGUS";
    return str;
}

bool DayaBay::DetectorSensor::bogus() const 
{
    // nothing to add
    return this->Detector::bogus();
}

// AdPmtSensor

DayaBay::AdPmtSensor::AdPmtSensor(int ring, int column, Site::Site_t site, 
                                  DetectorId::DetectorId_t detid)
    : DetectorSensor(ring<<8|column,site,detid)
{

}
DayaBay::AdPmtSensor::AdPmtSensor(int ring, int column, Site::Site_t site, 
                                  int ad_number)
    : DetectorSensor(ring<<8|column,site,
                     (DetectorId::DetectorId_t)(DetectorId::kAD1 + ad_number -1))
{
}
DayaBay::AdPmtSensor::~AdPmtSensor() {}


int DayaBay::AdPmtSensor::ring() const
{
    return (this->sensorId()&0x0000ff00)>>8;
}
 
int DayaBay::AdPmtSensor::column() const
{
    return this->sensorId()&0x000000ff;
}
std::ostream& DayaBay::operator<<(std::ostream& str, const DayaBay::AdPmtSensor& adsens)
{
    str << Site::AsString(adsens.site())
        << DetectorId::AsString(adsens.detectorId())
        << "("<<adsens.column()<<","<<adsens.ring()<<")";
    if (adsens.bogus()) str << " IS BOGUS";
    return str;
}

bool DayaBay::AdPmtSensor::bogus() const 
{
    if (this->Detector::bogus()) return true;
    if (! isAD() ) return true;

    // this hard coding of numerology is bad, but how else to check?
    if (!ring() && (column() < 1 || column() > 6)) { // r=0, c=[1,6] for calib pmts
        return true;
    }
    else if (ring() > 8 || column() < 1 || column() > 24) {
        return true;
    }
    return false;
}


// PoolPmtSensor

DayaBay::PoolPmtSensor::PoolPmtSensor(int wall_number, int wall_spot, bool inward_facing,
                                      Site::Site_t site, DetectorId::DetectorId_t detid)
    : DetectorSensor((inward_facing?(1<<12):0)|(wall_number<<8)|wall_spot,site,detid)
{
}


DayaBay::PoolPmtSensor::~PoolPmtSensor()
{
}

int DayaBay::PoolPmtSensor::wallNumber() const
{
    return (this->sensorId()&0x00000f00)>>8;
}
int DayaBay::PoolPmtSensor::wallSpot() const
{
    return this->sensorId()&0x000000ff;
}

bool DayaBay::PoolPmtSensor::inwardFacing() const
{
    return this->sensorId()&0x0000f000;
}


std::ostream& DayaBay::operator<<(std::ostream& str, const DayaBay::PoolPmtSensor& poolsens)
{
    str << Site::AsString(poolsens.site())
        << DetectorId::AsString(poolsens.detectorId())
        << "("
        <<poolsens.wallNumber()<<","
        <<poolsens.wallSpot()<<","
        <<poolsens.inwardFacing() << ")";
    if (poolsens.bogus()) str << " IS BOGUS";
    return str;
}

bool DayaBay::PoolPmtSensor::bogus() const 
{
    if (this->Detector::bogus()) return true;
    if (! isWaterShield() ) return true;

    // fixme: fill in with numerology

    return false;
}


// RpcSensor

DayaBay::RpcSensor::RpcSensor(int panelRow, int panelColumn, 
                              int layer, int strip,
                              Site::Site_t site, DetectorId::DetectorId_t detid)
  : DetectorSensor((panelRow<<12)|(panelColumn<<8)|(layer<<4)|strip,site,detid)
{
}


DayaBay::RpcSensor::~RpcSensor()
{
}

int DayaBay::RpcSensor::panelRow() const
{
    return (this->sensorId()&0x0000f000)>>12;
}

int DayaBay::RpcSensor::panelColumn() const
{
    return (this->sensorId()&0x00000f00)>>8;
}

int DayaBay::RpcSensor::layer() const
{
    return (this->sensorId()&0x000000f0)>>4;
}

int DayaBay::RpcSensor::strip() const
{
    return this->sensorId()&0x0000000f;
}

std::ostream& DayaBay::operator<<(std::ostream& str, 
                                  const DayaBay::RpcSensor& rpcsens)
{
    str << Site::AsString(rpcsens.site())
        << DetectorId::AsString(rpcsens.detectorId())
        << "("
        <<rpcsens.panelRow()<<","
        <<rpcsens.panelColumn()<<","
        <<rpcsens.layer()<<","
        <<rpcsens.strip()<< ")";
    if (rpcsens.bogus()) str << " IS BOGUS";
    return str;
}

bool DayaBay::RpcSensor::bogus() const 
{
    if (this->Detector::bogus()) return true;
    if (detectorId() != DetectorId::kRPC) {
        return true;
    }

    // fixme: fill in numerology
}

---