#include <cassert>
#include <iomanip>

#include "TrackAlignment.hh"


TrackAlignment::TrackAlignment(bool desy) {
  memset(this,0,sizeof(TrackAlignment));

  if(desy) {

    for(unsigned i(0);i<2;i++) {
      double offset(50.0*(i-0.5));
      _zLayer[i][0]=-  50.0+offset;
      _zLayer[i][1]=-1150.0+offset;
      _zLayer[i][2]=-2060.0+offset;
      _zLayer[i][3]=-3160.0+offset;
    }
    
    // X drift velocities per layer
    _vDrift[0][0]= 0.03;
    _vDrift[0][1]=-0.03*1.030;
    _vDrift[0][2]= 0.03*1.040;
    _vDrift[0][3]=-0.03;
    
    // Y drift velocities per layer
    _vDrift[1][0]=-0.03;
    _vDrift[1][1]= 0.03*1.045;
    _vDrift[1][2]=-0.03*1.030;
    _vDrift[1][3]= 0.03;
    
    for(unsigned i(0);i<2;i++) {
      for(unsigned j(0);j<4;j++) {
	if(i==0) _vDrift[i][j]*=1.01;
	if(i==1) _vDrift[i][j]*=0.97;
      }
    }
    
    // X corresponding to time = 0
    _cTzero[0][0]=-_vDrift[0][0]*1310.0;
    _cTzero[0][1]=-_vDrift[0][1]*1116.0+0.02;
    _cTzero[0][2]=-_vDrift[0][2]*1183.0+0.00;
    _cTzero[0][3]=-_vDrift[0][3]*1020.0;
    
    // Y corresponding to time = 0
    _cTzero[1][0]=-_vDrift[1][0]*1209.0;
    _cTzero[1][1]=-_vDrift[1][1]*1165.0-0.07;
    _cTzero[1][2]=-_vDrift[1][2]*1113.0-0.02;
    _cTzero[1][3]=-_vDrift[1][3]*1055.0;

    for(unsigned i(0);i<2;i++) {
      for(unsigned j(0);j<4;j++) {
	_cError[i][j]=0.5;
	_cEffic[i][j]=0.95;
      }
    }


  } else {

    for(unsigned i(0);i<2;i++) {
      double offset(29.0*(i-0.5));
      _zLayer[i][0]=-  29.0+offset;
      _zLayer[i][1]=- 680.0+offset;
      _zLayer[i][2]=-2528.0+offset;
      _zLayer[i][3]=0.0;
    }
    
    // X drift velocities per layer
    _vDrift[0][0]=0.2*32.0/25.0;
    _vDrift[0][1]=0.2*32.0/25.0;
    _vDrift[0][2]=0.2*32.0/25.0;
    _vDrift[0][3]=0.0;
    
    // Y drift velocities per layer
    _vDrift[1][0]=0.2*32.0/25.0;
    _vDrift[1][1]=0.2*32.0/25.0;
    _vDrift[1][2]=0.2*32.0/25.0;
    _vDrift[1][3]=0.0;
    
    // X corresponding to time = 0
    _cTzero[0][0]=-_vDrift[0][0]*0.0;
    _cTzero[0][1]=-_vDrift[0][1]*0.0;
    _cTzero[0][2]=-_vDrift[0][2]*0.0;
    _cTzero[0][3]=0.0;
    
    // Y corresponding to time = 0
    _cTzero[1][0]=-_vDrift[1][0]*0.0;
    _cTzero[1][1]=-_vDrift[1][1]*0.0;
    _cTzero[1][2]=-_vDrift[1][2]*0.0;
    _cTzero[1][3]=0.0;

    for(unsigned i(0);i<2;i++) {
      for(unsigned j(0);j<3;j++) {
	_cError[i][j]=0.2;
	_cEffic[i][j]=0.95;
      }
      _cError[i][3]=0.0;
      _cEffic[i][3]=0.0;
    }
  }
}

double TrackAlignment::zLayer(unsigned d, unsigned l) const {
  assert(d<=1 && l<=3);
  return _zLayer[d][l];
}

void TrackAlignment::zLayer(unsigned d, unsigned l, double z) {
  assert(d<=1 && l<=3);
  _zLayer[d][l]=z;
}

double TrackAlignment::cTzero(unsigned d, unsigned l) const {
  assert(d<=1 && l<=3);
  return _cTzero[d][l];
}

void TrackAlignment::cTzero(unsigned d, unsigned l, double c) {
  assert(d<=1 && l<=3);
  _cTzero[d][l]=c;
}

double TrackAlignment::vDrift(unsigned d, unsigned l) const {
  assert(d<=1 && l<=3);
  return _vDrift[d][l];
}

void TrackAlignment::vDrift(unsigned d, unsigned l, double z) {
  assert(d<=1 && l<=3);
  _vDrift[d][l]=z;
}

double TrackAlignment::cError(unsigned d, unsigned l) const {
  assert(d<=1 && l<=3);
  return _cError[d][l];
}

void TrackAlignment::cError(unsigned d, unsigned l, double e) {
  assert(d<=1 && l<=3);
  _cError[d][l]=e;
}

double TrackAlignment::cEffic(unsigned d, unsigned l) const {
  assert(d<=1 && l<=3);
  return _cEffic[d][l];
}

void TrackAlignment::cEffic(unsigned d, unsigned l, double e) {
  assert(d<=1 && l<=3);
  _cEffic[d][l]=e;
}

double TrackAlignment::coordinate(unsigned d, unsigned l, int t) const {
  assert(d<=1 && l<=3);
  return _vDrift[d][l]*t+_cTzero[d][l];
}

int TrackAlignment::tdcValue(unsigned d, unsigned l, double c) const {
  assert(d<=1 && l<=3);

  // int always rounds towards zero so compensate
  double t((c-_cTzero[d][l])/_vDrift[d][l]);
  if(t>=0.0) t+=0.5;
  else       t-=0.5;

  return (int)t;
}

std::ostream& TrackAlignment::print(std::ostream &o=std::cout) const {
  o << "TrackAlignment::print()" << std::endl;
  for(unsigned i(0);i<2;i++) {
    if(i==0) o << " X dimension" << std::endl;
    else     o << " Y dimension" << std::endl;
    for(unsigned j(0);j<4;j++) {
      o << "  Layer " << j
	<< ", z = " << std::setw(7) << _zLayer[i][j] <<std::endl
	<< "  Coordinate at t=0 = " << std::setw(9) << _cTzero[i][j]
	<< ", drift velocity = " << std::setw(9) << _vDrift[i][j] << std::endl
	<< "  Intrinsic error = " << std::setw(4) << _cError[i][j]
	<< ", intrinsic efficiency = " << std::setw(4) << _cEffic[i][j]
	<< std::endl;
    }
  }

  return o;
}

const int* TrackAlignment::intData() const {
  return 0;
}

int* TrackAlignment::intData() {
  return 0;
}

const int* TrackAlignment::floatData() const {
  return 0;
}

int* TrackAlignment::floatData() {
  return 0;
}

const double* TrackAlignment::doubleData() const {
  return _zLayer[0];
}

double* TrackAlignment::doubleData() {
  return _zLayer[0];
}