SlsDetectorEiger.cpp

//###########################################################################
// This file is part of LImA, a Library for Image Acquisition
//
// Copyright (C) : 2009-2011
// European Synchrotron Radiation Facility
// BP 220, Grenoble 38043
// FRANCE
//
// This 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 3 of the License, or
// (at your option) any later version.
//
// This software 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, see <http://www.gnu.org/licenses/>.
//###########################################################################

#include "SlsDetectorEiger.h"
#include "lima/MiscUtils.h"

#include <emmintrin.h>
#include <sched.h>

using namespace std;
using namespace lima;
using namespace lima::SlsDetector;
using namespace lima::SlsDetector::Defs;

const int Eiger::ChipSize = 256;
const int Eiger::ChipGap = 2;
const int Eiger::HalfModuleChips = 4;
const int Eiger::NbRecvPorts = EigerNbRecvPorts;

const int Eiger::BitsPerXfer = 4;
const int Eiger::SuperColNbCols = 8;
const double Eiger::BaseChipXferFreq = 200; // Mbit/s
const double Eiger::MaxFebBebBandwidth = 25600; // Mbit/s
const Eiger::LinScale Eiger::ChipXfer2Buff(2.59, 0.85);
const Eiger::LinScale Eiger::ChipRealReadout(1.074, -4);

const unsigned long Eiger::BebFpgaWritePtrAddr = 0xD10000C4;
const unsigned long Eiger::BebFpgaReadPtrAddr = 0xD10000E4;
const unsigned long Eiger::BebFpgaPtrRange = 0x10000000;

Eiger::CorrBase::CorrBase(Eiger *eiger)
	: m_eiger(eiger)
{
	DEB_CONSTRUCTOR();
	m_nb_eiger_modules = m_eiger->getNbEigerModules();
}

Eiger::CorrBase::~CorrBase()
{
	DEB_DESTRUCTOR();
	if (m_eiger)
		m_eiger->removeCorr(this);
}

void Eiger::CorrBase::prepareAcq()
{
	DEB_MEMBER_FUNCT();

	if (!m_eiger)
		THROW_HW_ERROR(InvalidValue) << "Correction already removed";

	const FrameDim& recv_dim = m_eiger->getRecvFrameDim();
	m_mod_frame_dim = recv_dim * Point(1, 2);
	m_frame_size = m_mod_frame_dim.getSize() * Point(1, m_nb_eiger_modules);
	m_inter_lines.resize(m_nb_eiger_modules);
	for (int i = 0; i < m_nb_eiger_modules - 1; ++i) {
		m_inter_lines[i] = m_eiger->getInterModuleGap(i);
		m_frame_size += Point(0, m_inter_lines[i]);
	}
	m_inter_lines[m_nb_eiger_modules - 1] = 0;
}

void Eiger::BadRecvFrameCorr::BadFrameData::reset()
{
	last_idx = 0;
	bad_frame_list.clear();
}

Eiger::BadRecvFrameCorr::BadRecvFrameCorr(Eiger *eiger)
	: CorrBase(eiger)
{
	DEB_CONSTRUCTOR();

	m_cam = m_eiger->getCamera();
}

void Eiger::BadRecvFrameCorr::prepareAcq()
{
	DEB_MEMBER_FUNCT();

	CorrBase::prepareAcq();
	m_bfd.reset();
}

void Eiger::BadRecvFrameCorr::correctFrame(FrameType frame, void *ptr)
{
	DEB_MEMBER_FUNCT();

	char *bptr = (char *) ptr;
	IntList& bfl = m_bfd.bad_frame_list;
	int& last_idx = m_bfd.last_idx;
	if (bfl.empty()) {
		int bad_frames = m_cam->getNbBadFrames(0);
		if (bad_frames == last_idx)
			return;
		m_cam->getBadFrameList(0, last_idx, bad_frames, bfl);
	}
	IntList::iterator end = bfl.end();
	if (find(bfl.begin(), end, frame) != end) {
		Eiger::Geometry *geom = m_eiger->getGeometry();
		for (int i = 0; i < geom->getNbRecvs(); ++i) {
			Eiger::Geometry::Recv *recv = geom->getRecv(i);
			recv->fillBadFrame(frame, bptr);
		}
	}
	if (*(end - 1) > int(frame))
		return;
	last_idx += bfl.size();
	bfl.clear();
}

Eiger::InterModGapCorr::InterModGapCorr(Eiger *eiger)
	: CorrBase(eiger)
{
	DEB_CONSTRUCTOR();
}

void Eiger::InterModGapCorr::prepareAcq()
{
	DEB_MEMBER_FUNCT();

	CorrBase::prepareAcq();

	m_gap_list.clear();

	int mod_size = m_mod_frame_dim.getMemSize();
	int width = m_mod_frame_dim.getSize().getWidth();
	int ilw = width * m_mod_frame_dim.getDepth();
	for (int i = 0, start = 0; i < m_nb_eiger_modules - 1; ++i) {
		start += mod_size;
		int size = m_inter_lines[i] * ilw;
		m_gap_list.push_back(Block(start, size));
		start += size;
	}
}

void Eiger::InterModGapCorr::correctFrame(FrameType /*frame*/, void *ptr)
{
	DEB_MEMBER_FUNCT();
	
	char *dest = static_cast<char *>(ptr);
	BlockList::const_iterator it, end = m_gap_list.end();
	for (it = m_gap_list.begin(); it != end; ++it) {
		int start = it->first;
		int size = it->second;
		memset(dest + start, 0, size);
	}
}

Data Eiger::ModelReconstruction::processModel(Data& data)
{
	DEB_MEMBER_FUNCT();

	DEB_PARAM() << DEB_VAR4(m_eiger, data.frameNumber, 
				_processingInPlaceFlag, data.data());
	if (!m_eiger)
		return data;

	Data ret = _processingInPlaceFlag ? data : data.copy();

	FrameType frame = ret.frameNumber;
	void *ptr = ret.data();
	CorrList& corr_list = m_eiger->m_corr_list;
	CorrList::iterator it, end = corr_list.end();
	for (it = corr_list.begin(); it != end; ++it)
		(*it)->correctFrame(frame, ptr);

	return ret;
}

Eiger::Geometry::Recv::FrameData::FrameData()
{
}

Eiger::Geometry::Recv::FrameData::FrameData(const Receiver::ImagePackets& /*image*/,
					    char *d)
	: dst(d)
{
}

Eiger::Geometry::Recv::Port::Port(Recv *recv, int port)
	: m_recv(recv), m_recv_idx(m_recv->m_idx), m_port(port)
{
	DEB_CONSTRUCTOR();
	DEB_PARAM() << DEB_VAR2(m_recv_idx, m_port);
	m_top_half_recv = (m_recv_idx % 2 == 0);
}

void Eiger::Geometry::Recv::Port::prepareAcq()
{
	DEB_MEMBER_FUNCT();
	DEB_PARAM() << DEB_VAR1(m_recv_idx);

	Geometry *geom = m_recv->m_eiger_geom;
	m_raw = geom->m_raw;
	const FrameDim& frame_dim = geom->m_recv_frame_dim;
	const Size& size = frame_dim.getSize();
	int depth = frame_dim.getDepth();
	m_dst.lw = size.getWidth() * depth;
	int recv_size = frame_dim.getMemSize();
	int src_port_offset = 0;
	int dst_port_offset = recv_size * m_recv_idx;

	m_pchips = HalfModuleChips / NbRecvPorts;
	m_src.cw = ChipSize * depth;
	m_dst.cw = m_src.cw;
	if (m_recv->m_pixel_depth_4)
		m_src.cw /= 2;
	m_src.lw = m_pchips * m_src.cw;

	if (m_raw) {
		// vert. port concat.
		dst_port_offset += ChipSize * m_dst.lw * m_port;
	} else {
		// inter-chip horz. gap
		m_dst.cw += ChipGap * depth;
		// horz. port concat.
		dst_port_offset += m_pchips * m_dst.cw * m_port;

		int mod_idx = m_recv_idx / 2;
		for (int i = 0; i < mod_idx; ++i)
			dst_port_offset += (geom->getInterModuleGap(i) *
					    m_dst.lw);
		if (m_top_half_recv) {
			// top-half module: vert-flipped data
			src_port_offset += (ChipSize - 1) * m_src.lw;
			m_src.lw *= -1;
		} else {
			// bottom-half module: inter-chip vert. gap
			dst_port_offset += (ChipGap / 2) * m_dst.lw;
		}
	}

	const int block_len = sizeof(__m128i);
	const int chip_blocks = ChipSize / 2 / block_len;

	const int port_lines = m_raw ? ChipSize : 1;
	m_port_blocks = chip_blocks * m_pchips * port_lines;
	DEB_TRACE() << DEB_VAR2(port_lines, m_port_blocks);
	m_src.len = ChipSize * abs(m_src.lw);
	m_src.off = src_port_offset;
	m_dst.off = dst_port_offset;
	DEB_TRACE() << DEB_VAR3(m_src.len, m_src.off, m_dst.off);
}

FrameDim Eiger::Geometry::Recv::Port::getSrcFrameDim()
{
	DEB_MEMBER_FUNCT();
	FrameDim fdim(abs(m_src.lw), ChipSize, Bpp8);
	DEB_RETURN() << DEB_VAR1(fdim);
	return fdim;
}

void Eiger::Geometry::Recv::Port::copy(char *dst, char *src)
{
	DEB_MEMBER_FUNCT();

	bool valid_data = (src != NULL);
	src += m_src.off;
	dst += m_dst.off;

	const int& lines = ChipSize;
	if (m_raw) {
		int size = m_src.lw * lines;
		if (valid_data)
			memcpy(dst, src, size);
		else
			memset(dst, 0xff, size);
		return;
	}

	for (int i = 0; i < lines; ++i, src += m_src.lw, dst += m_dst.lw) {
		char *s = src;
		char *d = dst;
		for (int j = 0; j < m_pchips; ++j, s += m_src.cw, d += m_dst.cw)
			if (valid_data)
				memcpy(d, s, m_src.cw);
			else
				memset(d, 0xff, m_src.cw);
	}
}

Eiger::Geometry::Recv::Recv(Geometry *eiger_geom, int idx)
	: m_eiger_geom(eiger_geom), m_idx(idx)
{
	DEB_CONSTRUCTOR();
	DEB_PARAM() << DEB_VAR1(m_idx);

	for (int i = 0; i < NbRecvPorts; ++i) {
		Port *p = new Port(this, i);
		m_port_list.push_back(p);
	}
}

int Eiger::Geometry::Recv::getNbPorts()
{
	DEB_MEMBER_FUNCT();
	DEB_RETURN() << DEB_VAR1(NbRecvPorts);
	return NbRecvPorts;
}

Eiger::Geometry::Recv::Port *Eiger::Geometry::Recv::getPort(int port_idx)
{
	DEB_MEMBER_FUNCT();
	return m_port_list[port_idx];
}

void Eiger::Geometry::Recv::prepareAcq()
{
	DEB_MEMBER_FUNCT();

	m_pixel_depth_4 = (m_eiger_geom->m_pixel_depth == PixelDepth4);

	PortList::iterator it, end = m_port_list.end();
	for (it = m_port_list.begin(); it != end; ++it)
		(*it)->prepareAcq();
}

void Eiger::Geometry::Recv::copy(const FrameData& data)
{
	DEB_MEMBER_FUNCT();
	for (int i = 0; i < getNbPorts(); ++i)
		m_port_list[i]->copy(data.dst, data.src[i]);
}

void Eiger::Geometry::Recv::fillBadFrame(FrameType frame, char *bptr)
{
	DEB_MEMBER_FUNCT();
	DEB_PARAM() << DEB_VAR2(m_idx, frame);
	FrameData data;
	for (int i = 0; i < getNbPorts(); ++i)
		data.src[i] = NULL;
	data.dst = bptr;
	processFrame(data);
}

void Eiger::Geometry::Recv::expandPixelDepth4(const FrameData& data)
{
	DEB_MEMBER_FUNCT();
	DEB_PARAM() << DEB_VAR3(DEB_HEX((unsigned long) data.src[0]),
				DEB_HEX((unsigned long) data.src[1]),
				DEB_HEX((unsigned long) data.dst));

	const int nb_ports = NbRecvPorts;
	Port *port = m_port_list[0];
	const bool raw = port->m_raw;
	int pi;
	char *src[EigerNbRecvPorts];
	for (pi = 0; pi < nb_ports; ++pi) {
		src[pi] = data.src[pi] + m_port_list[pi]->m_src.off;
		unsigned long s = (unsigned long) src[pi];
		if ((s & 15) != 0)
			THROW_HW_ERROR(Error) << "Missaligned src: "
					      << DEB_VAR1(DEB_HEX(s));
	}
	pi = 0;
	char *dst = data.dst + port->m_dst.off;
	unsigned long d = (unsigned long) dst;
	int dest_misalign = (d & 15);
	if (raw && dest_misalign)
		THROW_HW_ERROR(Error) << "Missaligned dest: "
				      << DEB_VAR1(DEB_HEX(d));

	DEB_TRACE() << DEB_VAR1(dest_misalign);
	DEB_TRACE() << DEB_VAR3(DEB_HEX((unsigned long) src[0]),
				DEB_HEX((unsigned long) src[1]),
				DEB_HEX((unsigned long) dst));
	bool valid_data = data.valid.test(pi);
	const int block_len = sizeof(__m128i);
	int nb_blocks = port->m_src.len * nb_ports / block_len;
	const int chip_blocks = ChipSize / 2 / block_len;
	const int port_blocks = port->m_port_blocks;
	const __m128i *src128 = (const __m128i *) src[pi];
	__m128i *dst128 = (__m128i *) dst;
	const __m128i m = _mm_set1_epi8(0xf);
	const int block_bits = block_len * 8;
	const int gap_bits = ChipGap * 8;
	const __m128i block64_bits128 = _mm_set_epi64x(0, 64);
	const __m128i gap_bits128 = _mm_set_epi64x(0, gap_bits);
	int shift_l = 0;
	__m128i shift_l128, shift_r128;
	__m128i m64_0 = _mm_set_epi64x(0, -1);
	__m128i m64_1 = _mm_set_epi64x(-1, 0);
 	bool reverse = (port->m_src.lw < 0);
	__m128i m0, prev;
	int chip_count = 0;

#define load_dst128()							\
	do {								\
		dest_misalign = ((unsigned long) dst & 15);		\
		dst128 = (__m128i *) (dst - dest_misalign);		\
		shift_l = dest_misalign * 8;				\
		shift_l128 = _mm_set_epi64x(0, shift_l % 64);		\
		shift_r128 = _mm_sub_epi64(block64_bits128, shift_l128); \
		if (shift_l != 0) {					\
			m0 = _mm_srl_epi64(_mm_set1_epi8(0xff), shift_r128); \
			if (shift_l < 64)				\
				m0 = _mm_and_si128(m0, m64_0);		\
			prev = _mm_and_si128(_mm_load_si128(dst128), m0); \
		} else {						\
			prev = _mm_setzero_si128();			\
		}							\
	} while (0)

#define pad_dst128()							\
	do {								\
		shift_l += gap_bits;					\
		if (shift_l % 64 == 0)					\
			shift_l128 = _mm_setzero_si128();		\
		else							\
			shift_l128 = _mm_add_epi64(shift_l128, gap_bits128); \
		shift_r128 = _mm_sub_epi64(block64_bits128, shift_l128); \
		if (shift_l == block_bits) {				\
			_mm_store_si128(dst128++, prev);		\
			prev = _mm_setzero_si128();			\
			shift_l = 0;					\
		}							\
	} while (0)

#define sync_dst128()							\
	do {								\
		if (shift_l != 0) {					\
			m0 = _mm_sll_epi64(_mm_set1_epi8(0xff), shift_l128); \
			if (shift_l >= 64)				\
				m0 = _mm_and_si128(m0, m64_1);		\
			__m128i a = _mm_and_si128(_mm_load_si128(dst128), m0); \
			_mm_store_si128(dst128, _mm_or_si128(prev, a));	\
		}							\
	} while (0)

	if (!raw)
		load_dst128();
	for (int i = 0; i < nb_blocks; ++i) {
		if (i == 0)
			DEB_TRACE() << DEB_VAR3(DEB_HEX((unsigned long) src128),
						DEB_HEX((unsigned long) dst128),
						nb_blocks);
		if (!raw && i && (i % chip_blocks == 0) &&
		    (++chip_count % HalfModuleChips > 0))
			pad_dst128();
		if (i && (i % port_blocks == 0)) {
			if (reverse)
				src128 -= 2 * port_blocks;
			src[pi++] = (char *) src128;
			pi %= nb_ports;
			valid_data = data.valid.test(pi);
			src128 = (const __m128i *) src[pi];
		}
		__m128i p4_raw;
		if (valid_data)
			p4_raw = _mm_load_si128(src128);
		else
			p4_raw = _mm_set1_epi8(0xff);
		++src128;
		__m128i p4_shr = _mm_srli_epi16(p4_raw, 4);
		__m128i i8_0 = _mm_and_si128(p4_raw, m);
		__m128i i8_1 = _mm_and_si128(p4_shr, m);
		__m128i p8_0 = _mm_unpacklo_epi8(i8_0, i8_1);
		__m128i p8_1 = _mm_unpackhi_epi8(i8_0, i8_1);
		if (raw) {
			_mm_store_si128(dst128++, p8_0);
			_mm_store_si128(dst128++, p8_1);
			continue;
		}
		__m128i p8_0l = _mm_sll_epi64(p8_0, shift_l128);
		__m128i p8_0r = _mm_srl_epi64(p8_0, shift_r128);
		__m128i p8_1l = _mm_sll_epi64(p8_1, shift_l128);
		__m128i p8_1r = _mm_srl_epi64(p8_1, shift_r128);
		__m128i d0, d1, d2, d3, d4;
		if (shift_l < 64) {
			d0 = p8_0l;
			d1 = p8_0r;
			d2 = p8_1l;
			d3 = p8_1r;
			d4 = _mm_setzero_si128();
		} else {
			d0 = _mm_setzero_si128();
			d1 = p8_0l;
			d2 = p8_0r;
			d3 = p8_1l;
			d4 = p8_1r;
		}
		__m128i d10 = _mm_slli_si128(d1, 8);
		__m128i d11 = _mm_srli_si128(d1, 8);
		__m128i d30 = _mm_slli_si128(d3, 8);
		__m128i d31 = _mm_srli_si128(d3, 8);
		prev = _mm_or_si128(prev, d0);
		_mm_store_si128(dst128++, _mm_or_si128(prev, d10));
		prev = _mm_or_si128(d11, d2);
		_mm_store_si128(dst128++, _mm_or_si128(prev, d30));
		prev = _mm_or_si128(d31, d4);
	}
	if (!raw)
		sync_dst128();
}

Eiger::Geometry::Geometry()
	: m_raw(false), m_image_type(Bpp16), m_pixel_depth(PixelDepth16)
{
	DEB_CONSTRUCTOR();
}

int Eiger::Geometry::getInterModuleGap(int det)
{
	DEB_MEMBER_FUNCT();
	if (det >= getNbEigerModules() - 1)
		THROW_HW_ERROR(InvalidValue) << "Invalid " << DEB_VAR1(det);
	return 36;
}

void Eiger::Geometry::setNbRecvs(int nb_recv)
{
	DEB_MEMBER_FUNCT();
	DEB_PARAM() << DEB_VAR1(nb_recv);

	int curr_nb_recv = m_recv_list.size();
	if (curr_nb_recv > nb_recv) {
		m_recv_list.resize(nb_recv);
		return;
	}

	for (int i = curr_nb_recv; i < nb_recv; ++i) {
		Recv *r = new Recv(this, i);
		m_recv_list.push_back(r);
	}
}

void Eiger::Geometry::prepareAcq()
{
	DEB_MEMBER_FUNCT();

	m_recv_frame_dim = getRecvFrameDim(m_raw);

	RecvList::iterator rit, rend = m_recv_list.end();
	for (rit = m_recv_list.begin(); rit != rend; ++rit)
		(*rit)->prepareAcq();
}

FrameDim Eiger::Geometry::getFrameDim(bool raw)
{
	DEB_MEMBER_FUNCT();
	DEB_PARAM() << DEB_VAR1(raw);
	FrameDim frame_dim = getRecvFrameDim(raw);
	Size size = frame_dim.getSize();
	size *= Point(1, getNbRecvs());
	if (!raw)
		for (int i = 0; i < getNbEigerModules() - 1; ++i)
			size += Point(0, getInterModuleGap(i));
	frame_dim.setSize(size);
	DEB_RETURN() << DEB_VAR1(frame_dim);
	return frame_dim;
}

FrameDim Eiger::Geometry::getRecvFrameDim(bool raw)
{
	DEB_MEMBER_FUNCT();
	DEB_PARAM() << DEB_VAR1(raw);
	FrameDim frame_dim;
	frame_dim.setImageType(m_image_type);
	Size size(ChipSize * HalfModuleChips, ChipSize);
	if (raw) {
		size /= Point(NbRecvPorts, 1);
		size *= Point(1, NbRecvPorts);
	} else {
		size += Point(ChipGap, ChipGap) * Point(3, 1) / Point(1, 2);
	}
	frame_dim.setSize(size);
	DEB_RETURN() << DEB_VAR1(frame_dim);
	return frame_dim;
}

Eiger::Beb::Beb(const std::string& host_name)
	: shell(host_name), fpga_mem(shell)
{
}

Eiger::Thread::Thread(Eiger *eiger, int idx)
	: m_eiger(eiger), m_idx(idx)
{
	DEB_MEMBER_FUNCT();

	AutoMutex l = lock();
	m_state = Init;

	start();

	struct sched_param param;
	param.sched_priority = 50;
	int ret = pthread_setschedparam(m_thread, SCHED_RR, &param);
	if (ret != 0)
		DEB_ERROR() << "Could not set real-time priority!!";

	while (m_state == Init)
		wait();
}

Eiger::Thread::~Thread()
{
	DEB_DESTRUCTOR();

	AutoMutex l = lock();
	m_state = Quitting;
	broadcast();
	while (m_state != End)
		wait();
}

void Eiger::Thread::threadFunction()
{
	DEB_MEMBER_FUNCT();

	State& s = m_state;

	AutoMutex l = lock();
	s = Ready;
	broadcast();

	while (s != Quitting) {
		while ((s == Ready) || (s == Stopping)
		       || ((s == Running) && m_eiger->allFramesAcquired())) {
			if (s == Stopping) {
				s = Ready;
				broadcast();
			}
			wait();
		}
		if (s == Running) {
			try {
				AutoMutexUnlock u(l);
				m_eiger->processPackets();
			} catch (Exception& e) {
				Camera *cam = m_eiger->getCamera();
				string name = ("Eiger::Thread::"
					       "threadFunction");
				cam->reportException(e, name);
			}
		}
	}

	s = End;
	broadcast();
}

void Eiger::Thread::setCPUAffinity(CPUAffinity aff)
{
	DEB_MEMBER_FUNCT();
	DEB_PARAM() << DEB_VAR1(aff);

        aff.applyToTask(getThreadID(), false);
}

void Eiger::Thread::prepareAcq()
{
	DEB_MEMBER_FUNCT();
}

Eiger::Eiger(Camera *cam)
	: Model(cam, EigerDet), m_fixed_clock_div(false)
{
	DEB_CONSTRUCTOR();

	int nb_det_modules = getNbDetModules();
	DEB_TRACE() << "Using Eiger detector, " << DEB_VAR1(nb_det_modules);

	NameList host_name_list = cam->getHostnameList();
	NameList::const_iterator it, end = host_name_list.end();
	for (it = host_name_list.begin(); it != end; ++it) {
		Beb *beb = new Beb(*it);
		m_beb_list.push_back(beb);
	}

	m_geom.setNbRecvs(nb_det_modules);

	for (int i = 0; i < nb_det_modules; ++i)
		m_recv_list.push_back(cam->getRecv(i));

	setNbProcessingThreads(1);

	if (isTenGigabitEthernetEnabled()) {
		DEB_TRACE() << "Forcing 10G Ethernet flow control";
		setFlowControl10G(true);
	}

	m_reconstruction = new ModelReconstruction(this);

	updateCameraModel();

	getClockDiv(m_clock_div);
}

Eiger::~Eiger()
{
	DEB_DESTRUCTOR();
	getCamera()->waitAcqState(Idle);
	m_reconstruction->m_eiger = NULL;
	m_reconstruction->unref();
	removeAllCorr();
}

void Eiger::getFrameDim(FrameDim& frame_dim, bool raw)
{
	DEB_MEMBER_FUNCT();
	DEB_PARAM() << DEB_VAR1(raw);
	frame_dim = m_geom.getFrameDim(raw);
	DEB_RETURN() << DEB_VAR1(frame_dim);
}

void Eiger::getDetMap(Data& /*det_map*/)
{
	DEB_MEMBER_FUNCT();
	THROW_HW_ERROR(NotSupported) << "DetMap not implemented yet";
}

string Eiger::getName()
{
	DEB_MEMBER_FUNCT();
	ostringstream os;
	os << "PSI/Eiger-";
	int nb_modules = getNbEigerModules();
	if (nb_modules == 1) {
		os << "500k";
	} else if (nb_modules % 2 == 0) {
		os << (nb_modules / 2) << "M";
	} else {
		os << nb_modules << "-Modules";
	}
	string name = os.str();
	DEB_RETURN() << DEB_VAR1(name);
	return name;
}

void Eiger::getPixelSize(double& x_size, double& y_size)
{
	DEB_MEMBER_FUNCT();
	x_size = y_size = 75e-6;
	DEB_RETURN() << DEB_VAR2(x_size, y_size);
}

void Eiger::getDACInfo(NameList& name_list, IntList& idx_list,
		       IntList& milli_volt_list)
{
	DEB_MEMBER_FUNCT();

#define EIGER_DAC(x)			{x, 0}
#define EIGER_DAC_MV(x)			{x, 1}

	static struct DACData {
		DACIndex idx;
		int milli_volt;
	} EigerDACList[] = {
		EIGER_DAC(EigerVcmpLL),
		EIGER_DAC(EigerVcmpLR),
		EIGER_DAC(EigerVcmpRL),
		EIGER_DAC(EigerVcmpRR),
		EIGER_DAC(Threshold),
	};
	const unsigned int size = C_LIST_SIZE(EigerDACList);

	name_list.resize(size);
	idx_list.resize(size);
	milli_volt_list.resize(size);
	struct DACData *data = EigerDACList;
	for (unsigned int i = 0; i < size; ++i, ++data) {
		ostringstream os;
		os << data->idx;
		name_list[i] = os.str();
		idx_list[i] = int(data->idx);
		milli_volt_list[i] = data->milli_volt;
		DEB_RETURN() << DEB_VAR2(name_list[i], idx_list[i]);
	}
}

void Eiger::getADCInfo(NameList& name_list, IntList& idx_list,
		       FloatList& factor_list, FloatList& min_val_list)
{
	DEB_MEMBER_FUNCT();

#define EIGER_TEMP_FACTOR		(1 / 1000.0)

#define EIGER_TEMP(x)			{x, EIGER_TEMP_FACTOR, 0}

	static struct ADCData {
		ADCIndex idx;
		double factor, min_val;
	} EigerADCList[] = {
		EIGER_TEMP(TempFPGA),
		EIGER_TEMP(TempFPGAExt),
		EIGER_TEMP(Temp10GE),
		EIGER_TEMP(TempDCDC),
		EIGER_TEMP(TempSODL),
		EIGER_TEMP(TempSODR),
		EIGER_TEMP(TempFPGAFL),
		EIGER_TEMP(TempFPGAFR),
	};
	const unsigned int size = C_LIST_SIZE(EigerADCList);

	name_list.resize(size);
	idx_list.resize(size);
	factor_list.resize(size);
	min_val_list.resize(size);
	struct ADCData *data = EigerADCList;
	for (unsigned int i = 0; i < size; ++i, ++data) {
		ostringstream os;
		os << data->idx;
		name_list[i] = os.str();
		idx_list[i] = int(data->idx);
		factor_list[i] = data->factor;
		min_val_list[i] = data->min_val;
		DEB_RETURN() << DEB_VAR4(name_list[i], idx_list[i], 
					 factor_list[i], min_val_list[i]);
	}
}

void Eiger::getTimeRanges(TimeRanges& time_ranges)
{
	DEB_MEMBER_FUNCT();

	PixelDepth pixel_depth;
	Camera* cam = getCamera();
	cam->getPixelDepth(pixel_depth);
	ClockDiv clock_div;
	getClockDiv(clock_div);
	ParallelMode parallel_mode;
	getParallelMode(parallel_mode);

	calcTimeRanges(pixel_depth, clock_div, parallel_mode, time_ranges);

	double readout_time;
	measureReadoutTime(readout_time);
}

void Eiger::calcTimeRanges(PixelDepth pixel_depth, ClockDiv clock_div,
			   ParallelMode parallel_mode,
			   TimeRanges& time_ranges)
{
	DEB_STATIC_FUNCT();
	DEB_PARAM() << DEB_VAR3(pixel_depth, clock_div, parallel_mode);

	// times are in usec, freq in MHz
	int period_factor = 1 << int(clock_div);
	double xfer_freq = BaseChipXferFreq / period_factor;
	DEB_TRACE() << DEB_VAR2(period_factor, xfer_freq);

	double xfer_2_buff = ChipXfer2Buff.calcY(period_factor);
	DEB_TRACE() << DEB_VAR1(xfer_2_buff);

	const int super_col_pixels = SuperColNbCols * ChipSize;
	double theo_single_readout = super_col_pixels * BitsPerXfer / xfer_freq;
	// theoretical -> measured correction
	double real_single_readout = ChipRealReadout.calcY(theo_single_readout);
	DEB_TRACE() << DEB_VAR2(theo_single_readout, real_single_readout);

	int readout_cycles;
	if (pixel_depth == PixelDepth4)
		readout_cycles = 1;
	else if (pixel_depth == PixelDepth8)
		readout_cycles = 2;
	else
		readout_cycles = 3;
	double min_chip_readout = real_single_readout * readout_cycles;
	DEB_TRACE() << DEB_VAR2(readout_cycles, min_chip_readout);

	int mem_xfer_blocks = pixel_depth / BitsPerXfer;
	const int nb_super_cols = ChipSize / SuperColNbCols * HalfModuleChips;
	double feb_beb_bw = (xfer_freq * nb_super_cols / readout_cycles *
			     mem_xfer_blocks);
	DEB_TRACE() << DEB_VAR2(feb_beb_bw, MaxFebBebBandwidth);
	double chip_readout = min_chip_readout;
	if (feb_beb_bw > MaxFebBebBandwidth) {
		chip_readout *= feb_beb_bw / MaxFebBebBandwidth;
		DEB_TRACE() << "limiting chip readout freq: "
			    << DEB_VAR2(min_chip_readout, chip_readout);
	}
	double full_readout = xfer_2_buff + chip_readout;
	DEB_TRACE() << DEB_VAR1(full_readout);

	bool parallel = (parallel_mode == Parallel);

	double min_exp = 10;
	double min_period = (parallel ? 0 : min_exp) + full_readout;
	double min_lat = parallel ? xfer_2_buff : full_readout;

	// Timing hardware uses 32-bit, base-10 floating-point registers:
	//   29 bits: mantissa
	//    3 bits: exponent
	// Time unit: 10 nsec 
	// Max value: 2^29 * 10^(2^3 - 1) * 10 nsec = 1.7 years
	// Using 1000 sec as a reasonable upper limit

	time_ranges.min_exp_time = min_exp * 1e-6;
	time_ranges.max_exp_time = 1e3;
	time_ranges.min_lat_time = min_lat * 1e-6;
	time_ranges.max_lat_time = 1e3;
	time_ranges.min_frame_period = min_period * 1e-6;
	time_ranges.max_frame_period = 1e3;

	DEB_RETURN() << DEB_VAR2(time_ranges.min_exp_time, 
				 time_ranges.max_exp_time);
	DEB_RETURN() << DEB_VAR2(time_ranges.min_lat_time, 
				 time_ranges.max_lat_time);
	DEB_RETURN() << DEB_VAR2(time_ranges.min_frame_period, 
				 time_ranges.max_frame_period);
}

void Eiger::measureReadoutTime(double& /*readout_time*/)
{
	DEB_MEMBER_FUNCT();

	Camera* cam = getCamera();

	class SyncParams
	{


	private:
		double prev_exp, prev_period;
		TrigMode prev_trig_mode;
	};

	// exp, period, trigmode, nb_frames
	double prev_exp, prev_period;
	cam->getExpTime(prev_exp);
	cam->getFramePeriod(prev_period);
	FrameType prev_nb_frames;
	cam->getNbFrames(prev_nb_frames);
	Defs::TrigMode prev_trig_mode;
	cam->getTrigMode(prev_trig_mode);


	/*
	DEB_ALWAYS() << "calling startAcquisition";
	cam->m_det->startAcquisition();

	DEB_ALWAYS() << "calling stopAcquisition";
	cam->m_det->stopAcquisition();

	readout_time = 0;
	 */
}

int Eiger::getNbFrameMapItems()
{
	DEB_MEMBER_FUNCT();
	int nb_items = 1;
	DEB_RETURN() << DEB_VAR1(nb_items);
	return nb_items;
}

void Eiger::updateFrameMapItems(FrameMap *map)
{
	DEB_MEMBER_FUNCT();
}

void Eiger::updateImageSize()
{
	DEB_MEMBER_FUNCT();

	removeAllCorr();

	createBadRecvFrameCorr();

	Camera *cam = getCamera();

	bool raw;
	cam->getRawMode(raw);
	ImageType image_type = cam->getImageType();
	PixelDepth pixel_depth;
	cam->getPixelDepth(pixel_depth);

	DEB_TRACE() << DEB_VAR3(raw, image_type, pixel_depth);

	m_geom.setRaw(raw);
	m_geom.setPixelDepth(pixel_depth);
	m_geom.setImageType(image_type);
	m_geom.prepareAcq();

	if (raw)
		return;

	createChipBorderCorr(image_type);