//
// $Id: SiChannelGeometer.cpp,v 1.38 2005/11/29 23:46:29 snyder Exp $
//
// File: SiChannelGeometer.cpp
// Purpose: Make SiStrips for the requested ladder/wedge
// Created: 15-DEC-1997   John Hobbs
// Modified: 8-MAR-1998   Ela Barberis
//
// Jan 30, 2005 by Shaohua Fu
// added Layer0 // SFL0_Jan_2005
// function overloaded to be backward compatible
// Be very careful that different schemes are used for building the L0 geometry (2 layers, 3 ladders) and using it (1 layer, 6 ladders) // SFL0_Jan_2005
//
// $Revision: 1.38 $
//
//

// Include files
#include <cassert>
#include <iostream>
#include <string>
#include <ErrorLogger/ErrorLog.h>
#include <rcp/RCPManager.hpp>                          // RCP stuff
#include <rcp/RCP.hpp>
#include <stdexcept>
#include "smtutil/SmtAddress.hpp"
#include "silicon_geometry/channel/utils/Map.hpp"

#include <silicon_geometry/base/SiBaseGeometry.hpp>
#include <geometry_system/management/HandleSystem.hpp>
#include "SiChannelGeometer.hpp"
#include "SiStrips.hpp"
#include "d0_util/formatting.hpp"

using namespace silicon_geom;
using namespace std;
using namespace dgs;
using edm::RCPManager;
using edm::RCP;
using std::string;

// Judging by the example in framework/Package, I think this is OK...
ErrorLog theLog;

// Control access to myself
SiChannelGeometer* SiChannelGeometer::_instance=0;
bool SiChannelGeometer::_existence=false;
bool SiChannelGeometer::_load_maps=false;

namespace {
  void clear_maps(std::map<int,silicon_geom::Map*> maps) ;
  static int sub_version=0;
}

SiChannelGeometer::SiChannelGeometer(): _dataVersionGrabber(0)
{ 
  // Get the parameters
  RCPManager *rcpman = RCPManager::instance();
  RCP trcp = rcpman->extract("silicon_geometry","smt_version_matching");
  vector<RCP> versRCPs = trcp.getVRCP("channel_versions");
  vector<int> versIDs = trcp.getVInt("version_number");
  vector<int> time_stamps = trcp.getVInt("time_stamps");
  vector<string> map_files = trcp.getVString("map_files");
  assert( versIDs.size() == versRCPs.size() );
  assert( versIDs.size() == time_stamps.size() );
  assert( versIDs.size() == map_files.size() );

  // build the map and store the default version ID...
  for( int i=0; i<versRCPs.size() ; i++ ) {
    _versRCPs[versIDs[i]] = versRCPs[i];
    _maps[versIDs[i]] = new Map(map_files[i]);
    _timestamps[versIDs[i]] = time_stamps[i];
  }

  _defaultRCPID = versRCPs[versRCPs.size()-1].getRCPID();
  _defaultVID = versIDs[versRCPs.size()-1];

  // and make sure this is checked every event (See absRcpGeometer)
  _check_every_event = true;
}

SiChannelGeometer::~SiChannelGeometer() { 
  std::map<int,Map*>::iterator imap;
  for(imap = _maps.begin() ; imap != _maps.end() ; ++imap ) {
    delete imap->second;
  }
  _maps.clear();
}

// Global definitions
SiChannelGeometer* SiChannelGeometer::get_instance()
{
  if( !_instance ) _instance = new SiChannelGeometer;
  return _instance;
}

bool SiChannelGeometer::check_channelgeom()
//
// Purpose: Return true if a SiChannelGeometer exists
//
{
    return _existence;
}

bool SiChannelGeometer::refresh(const RCP* channel_map)
//
// Purpose:  Update the silicon channel geometer using an RCP file
//
{
  _instance->build_default(channel_map);
  return true;
}

// Abbreviation
namespace {
inline
std::string itoa(int x) { return d0_util::format_number (x); }


// We must be very careful about encode(), because we use different schemes for building the L0 geometry (2 layers, 3 ladders) and using it (1 layer, 6 ladders) // SFL0_Jan_2005
// The original encode() will be used for normal barrels, and for L0 1-layer 6-ladder scheme // SFL0_Jan_2005
unsigned int  encode(int bar,int lyr,int lad,int view) {
  // bar 3 bits
  // lyr 4 bits
  // lad 4 bits
  // view 1 bits
  int BAR_BIT=3;
  int LYR_BIT=4;
  int LAD_BIT=4;
  int VIEW_BIT=1;
  assert(lyr<=16);
  assert(lad<=16);
  assert(view<=2);
  unsigned int pack= (bar-1)<<(VIEW_BIT+LAD_BIT+LYR_BIT) |
    (lyr-1)<<(VIEW_BIT+LAD_BIT) |
    (lad-1)<<(VIEW_BIT) |
    (view-1);
  return pack;
}

// The new encode_L0() will be used for L0 2-layer 3-ladder scheme when building L0 geometry // SFL0_Jan_2005
// added SFL0_Jan_2005
unsigned int  encode_L0(int bar,int lyr,int lad,int view) {
  // bar 3 bits
  // lyr 4 bits
  // lad 4 bits
  // view 1 bits
  int BAR_BIT=3;
  int LYR_BIT=4;
  int LAD_BIT=4;
  int VIEW_BIT=1;
  assert(lyr<=16);
  assert(lad<=16);
  assert(view<=2);
  if (lyr==1) {
    if (lad==1) lad=1;
    else if (lad==2) lad=3;
    else if (lad==3) lad=5;
  }
  else if (lyr==2) {
    if (lad==1) lad=2;
    else if (lad==2) lad=4;
    else if (lad==3) lad=6;
    lyr=1;
  }
  unsigned int pack= (bar-1)<<(VIEW_BIT+LAD_BIT+LYR_BIT) |
    (lyr-1)<<(VIEW_BIT+LAD_BIT) |
    (lad-1)<<(VIEW_BIT) |
    (view-1);
  return pack;
}
// end of SFL0_Jan_2005
}


void SiChannelGeometer::build_default(const RCP* channel_map/*0*/)
//
// Purpose: Create the internal information needed to map ladder/wedge and
//          view ID's onto a given layout.  
//
{
  int j;  //MSVC5 bug workaround
  
  // get the geometer for the ladder/wedge information
  static SiGeometer* SiG=0;
  if( !SiG ) {
    SiG = SiGeometer::get_instance();
    if( !SiG->check_silicon() ) ERRLOGTO(theLog,ELfatal,"No base geometry") << endmsg;
  }

  // Clear out everything to allow for a rebuild from scratch
  _views_b.clear();
  _barrel_strips.clear();
  _views_l0b.clear(); // added SFL0_Jan_2005
  _l0barrel_strips.clear(); // added SFL0_Jan_2005
  _Fdisk_coarse_strips.clear();
  _Fdisk_fine_strips.clear();    
  _Hdisk_coarse_strips.clear();
  _Hdisk_fine_strips.clear();

  bool goodrcp = true;

  //for ( j=1; j<=SiG->get_barrel_count() ; j++) { // cmt.out SFL0_Jan_2005
  for ( j=1; j<=SiG->get_barrel_count(0) ; j++) { // added SFL0_Jan_2005
    //for (int k=1; k<=SiG->get_layer_count() ; k++) { // cmt.out SFL0_Jan_2005
    for (int k=1; k<=SiG->get_layer_count(0) ; k++) { // added SFL0_Jan_2005
      
          int view_type =  channel_map->getInt("B"+itoa(j)+"_type");

          int barrel_views = channel_map->getInt("B_ty"+itoa(view_type)
                           +"_l"+itoa(k)+"_views");

          _views_b.push_back(barrel_views);

          int stype   =  channel_map->getInt("B_l"+itoa(k)+"_stype");
 

      //for (int l=1; l<=SiG->get_ladder_count((k+SiG->get_layer_count()*(j-1))-1) ; l++){ // cmt.out SFL0_Jan_2005
      for (int l=1; l<=SiG->get_ladder_count(0, (k+SiG->get_layer_count(0)*(j-1))-1) ; l++){ // added SFL0_Jan_2005

         //Handle<const SiLadder> location = SiG->get_ladder_handle(j,k,l);  // cmt.out SFL0_Jan_2005
	 Handle<const SiLadder> location = SiG->get_ladder_handle(0,j,k,l); // added SFL0_Jan_2005  
	 //          int indexlad = SiG->make_handle_l_id(j,k,l);
 
         //for (int view=1; view<=_views_b[(k+SiG->get_layer_count()*(j-1))-1]; view++) { // cmt.out SFL0_Jan_2005
         for (int view=1; view<=_views_b[(k+SiG->get_layer_count(0)*(j-1))-1]; view++) { // added SFL0_Jan_2005

            float pitch  =  channel_map->getFloat("B_v"+itoa(view)+"_st"
                            +itoa(stype)+"_pitch");
            float stereo =  channel_map->getFloat("B_v"+itoa(view)+"_st"
                            +itoa(stype)+"_stereo");
            float strip0 =  channel_map->getFloat("B_v"+itoa(view)+"_st"
                            +itoa(stype)+"_strip0");
            float nstrip =  channel_map->getFloat("B_v"+itoa(view)+"_st"
                            +itoa(stype)+"_nstrip");
	    double err_fact=1.,err_term=0.;
            if (goodrcp)
              try {
                err_fact = channel_map->getFloat("B_v"+itoa(view)+"_st"
                                                 +itoa(stype)+"_err_fact");
                err_term = channel_map->getFloat("B_v"+itoa(view)+"_st"
                                                 +itoa(stype)+"_err_const_term");
              }
              catch(...)
              { goodrcp = false; }
	    unsigned int index = encode(j,k,l,view);
            SiLadderStrips* unit = new SiLadderStrips(pitch,
                                          stereo,
                                          strip0,
                                          nstrip,
                                          view,
					  err_fact,
					  err_term,
                                          location);
	    if(_barrel_strips.size() <= index )
	      _barrel_strips.resize(index+1);
            _barrel_strips[index]=unit;

         }
       }
      }
     }

  // added SFL0_Jan_2005
  // create Layer 0 barrels
  goodrcp = true;
  try {
    channel_map->getInt("L0B1_type");
  }
  catch (...) { goodrcp = false; }
  if (goodrcp)
  for (int j=1; j<=SiG->get_barrel_count(3) ; j++) {
    for (int k=1; k<=SiG->get_layer_count(3) ; k++) {
          int view_type =  channel_map->getInt("L0B"+itoa(j)+"_type");
          int barrel_views = channel_map->getInt("L0B_ty"+itoa(view_type)+"_l"+itoa(k)+"_views");
          _views_l0b.push_back(barrel_views);
          int stype   =  channel_map->getInt("L0B_l"+itoa(k)+"_stype");
      for (int l=1; l<=SiG->get_ladder_count(3, (k+SiG->get_layer_count(3)*(j-1))-1) ; l++){
	 Handle<const SiLadder> location = SiG->get_ladder_handle_L0(3,j,k,l);
         for (int view=1; view<=_views_l0b[(k+SiG->get_layer_count(3)*(j-1))-1]; view++) {
            float pitch  =  channel_map->getFloat("L0B_v"+itoa(view)+"_st"+itoa(stype)+"_pitch");
            float stereo =  channel_map->getFloat("L0B_v"+itoa(view)+"_st"+itoa(stype)+"_stereo");
            float strip0 =  channel_map->getFloat("L0B_v"+itoa(view)+"_st"+itoa(stype)+"_strip0");
            float nstrip =  channel_map->getFloat("L0B_v"+itoa(view)+"_st"+itoa(stype)+"_nstrip");
	    double err_fact=1.,err_term=0.;
	    try {
	     err_fact = channel_map->getFloat("L0B_v"+itoa(view)+"_st"+itoa(stype)+"_err_fact");
	     err_term = channel_map->getFloat("L0B_v"+itoa(view)+"_st"+itoa(stype)+"_err_const_term");
	    }
	    catch(...){}
	    unsigned int index = encode_L0(j,k,l,view);
            SiLadderStrips* unit = new SiLadderStrips(pitch,
                                          stereo,
                                          strip0,
                                          nstrip,
                                          view,
					  err_fact,
					  err_term,
                                          location);
	    if(_l0barrel_strips.size() <= index )
	      _l0barrel_strips.resize(index+1);
            _l0barrel_strips[index]=unit;
	 }
      }
    }
  }
  // end of SFL0_Jan_2005



//create F disks, coarse geometry access (.i.e. disk, wedge, view)

      _views_F = channel_map->getInt("Fwed_views");

      goodrcp = true;
      for ( j=1; j<=SiG->get_disk_count(1) ; j++) { 
          for (int l=1; l<=SiG->get_wedgeholder_count(1) ; l++) {

             Handle<const SiWedge> location = SiG->get_wedge_handle(1,j,l);   
	     //             int indexwed = SiG->make_handle_w_id(1,j,l);

             for (int view=1; view<=_views_F; view++) {

              float pitch  = channel_map->getFloat("Fwed_v"+itoa(view)
                                          +"_pitch");
              float stereo = channel_map->getFloat("Fwed_v"+itoa(view)
                                          +"_stereo");
              float strip0 = channel_map->getFloat("Fwed_v"+itoa(view)
                                          +"_strip0");
              float nstrip = channel_map->getFloat("Fwed_v"+itoa(view)
                                          +"_nstrip");
	      double err_fact=1.,err_term=0.;
              if (goodrcp)
                try {
                  err_fact = channel_map->getFloat("Fwed_v"+itoa(view) 
                                                   +"_err_fact");
                  err_term = channel_map->getFloat("Fwed_v"+itoa(view)
                                                   +"_err_const_term");
                }
                catch(...)
                {goodrcp = false;}
              SiWedgeStrips* unit = new SiWedgeStrips(pitch,
                                           stereo,
                                           strip0,
                                           nstrip,
                                           view,  
					   err_fact,
					   err_term,
                                           location);
	     
             _Fdisk_coarse_strips.push_back(unit);

	     }           
	  }
	}

//create F disks, fine geometry access (.i.e. disk, subdisk, wedge, view)

      goodrcp = true;
      for ( j=1; j<=SiG->get_disk_count(1) ; j++) { 
        for (int k=1; k<=SiG->get_subdisk_count(1) ; k++) { 
           for (int l=1; l<=(SiG->get_wedgeholder_count(1)/SiG->get_subdisk_count(1)) ; l++) {

             Handle<const SiWedge> location = 
                            SiG->get_wedge_handle(1,j,k,l);   
	     //             int indexwed = SiG->make_handle_w_id(1,j,l);

             for (int view=1; view<=_views_F; view++) {

              float pitch  = channel_map->getFloat("Fwed_v"+itoa(view)
                                          +"_pitch");
              float stereo = channel_map->getFloat("Fwed_v"+itoa(view)
                                          +"_stereo");
              float strip0 = channel_map->getFloat("Fwed_v"+itoa(view)
                                          +"_strip0");
              float nstrip = channel_map->getFloat("Fwed_v"+itoa(view)
                                          +"_nstrip");
	      double err_fact=1.,err_term=0.;
              if (goodrcp)
                try{
                  err_fact = channel_map->getFloat("Fwed_v"+itoa(view) 
                                                   +"_err_fact");
                  err_term = channel_map->getFloat("Fwed_v"+itoa(view)
                                                   +"_err_const_term");
                }
                catch(...)
                {goodrcp = false;}
              SiWedgeStrips* unit = new SiWedgeStrips(pitch,
                                           stereo,
                                           strip0,
					   nstrip,	      
					   view,  
					   err_fact,
					   err_term,
                                           location);
	     
             _Fdisk_fine_strips.push_back(unit);

	     }           
	   }
	  }
	}

//create H disks, coarse geometry access (.i.e. disk, wedge, view)

      goodrcp = true;
     for ( j=1; j<=SiG->get_disk_count(2) ; j++) { 
         for (int l=1; l<=SiG->get_wedge_count(2); l++){

           Handle<const SiWedge> location = SiG->get_wedge_handle(2,j,l);   
	   //           Handle<const SiWedge> location = SiG->get_wedge_handle(2,j,(l+1)/2);   
	   //	   int indexwed = SiG->make_handle_w_id(2,j,l);

// for the H disks the two wedges attached to each wedgeholder
// are treated as two opposite views of the same object, in order
// to keep parallelism with the F disks structure which has
// double sided detectors. 

           int view  =  (l+1)%2+1;
           
           float pitch  =  channel_map->getFloat("Hwed_v"+itoa(view)+"_pitch");
           float stereo =  channel_map->getFloat("Hwed_v"+itoa(view)+"_stereo");
           float strip0 =  channel_map->getFloat("Hwed_v"+itoa(view)+"_strip0");
           float nstrip =  channel_map->getFloat("Hwed_v"+itoa(view)+"_nstrip");
	   double err_fact=1.,err_term=0.;
           if (goodrcp)
             try {
               err_fact = channel_map->getFloat("Hwed_v"+itoa(view) 
                                                +"_err_fact");
               err_term = channel_map->getFloat("Hwed_v"+itoa(view)
                                                +"_err_const_term");
             }
             catch(...)
             {goodrcp = false;}
           SiWedgeStrips* unit;

           try {

           unit = new SiWedgeStrips(pitch,
                                         stereo,
                                         strip0,
                                         nstrip, 
                                         view, 
 					 err_fact,
					 err_term,
                                        location);
	   }

	   catch(runtime_error mistake) {
	     std::cerr << "Caught error: " << mistake.what() << endl;
	     exit(1);
	   }

           _Hdisk_coarse_strips.push_back(unit);
       }
     }

//create H disks, fine geometry access (.i.e. disk, subdisk, wedge, view)

     goodrcp = true;
     for ( j=1; j<=SiG->get_disk_count(2) ; j++) { 
        for (int k=1; k<=SiG->get_subdisk_count(2) ; k++) { 
         for (int l=1; l<=(SiG->get_wedge_count(2)/SiG->get_subdisk_count(2)) ; l++){

	   //           Handle<const SiWedge> location = SiG->get_wedge_handle(2,j,k,l);   
	   Handle<const SiWedge> location = SiG->get_wedge_handle(2,j,k,(l+1)/2);   
	   //           int indexwed = SiG->make_handle_w_id(2,j,l);
// for the H disks the two wedges attached to each wedgeholder
// are treated as two opposite views of the same object, in order
// to keep parallelism with the F disks structure which has
// double sided detectors. 

           int view  =  (l+1)%2+1;
           
           float pitch  =  channel_map->getFloat("Hwed_v"+itoa(view)+"_pitch");
           float stereo =  channel_map->getFloat("Hwed_v"+itoa(view)+"_stereo");
           float strip0 =  channel_map->getFloat("Hwed_v"+itoa(view)+"_strip0");
           float nstrip =  channel_map->getFloat("Hwed_v"+itoa(view)+"_nstrip");
	   double err_fact=1.,err_term=0.;
           if (goodrcp)
             try{
               err_fact = channel_map->getFloat("Hwed_v"+itoa(view) 
                                                +"_err_fact");
               err_term = channel_map->getFloat("Hwed_v"+itoa(view)
                                                +"_err_const_term");
             }
             catch(...)
             {goodrcp = false;}
           SiWedgeStrips* unit = new SiWedgeStrips(pitch,
                                         stereo,
                                         strip0,
                                         nstrip, 
                                         view, 
					 err_fact,
					 err_term,
                                         location);
           _Hdisk_fine_strips.push_back(unit);
       }
     }
    }


     // create the map 
     int ver=-1;
     std::map<int,edm::RCP>::const_iterator imap;
     for( imap = _versRCPs.begin() ; imap !=_versRCPs.end()  ; ++imap )
       if( imap->second.getRCPID() == channel_map->getRCPID() )
	 ver = imap->first;
     if( ver >= 0 && _load_maps) {
       Map* map = _maps[ver];
       bool stat = map->load_map();
       assert( stat );
     }

     _existence = true;
}

// Accessors


int SiChannelGeometer::get_view_count(int barrel, int layer, int ladder) // cmt.out SFL0_Jan_2005
{

  static SiGeometer* SiG=0;
  if( !SiG ) {
    SiG = SiGeometer::get_instance();
    if( !SiG ) ERRLOGTO(theLog,ELfatal,"No base geometry") << endmsg;
  }

 return _views_b[(layer+SiG->get_layer_count()*(barrel-1))-1];
}

int SiChannelGeometer::get_view_count(int bartype, int barrel, int layer, int ladder) // added SFL0_Jan_2005
{

  static SiGeometer* SiG=0;
  if( !SiG ) {
    SiG = SiGeometer::get_instance();
    if( !SiG ) ERRLOGTO(theLog,ELfatal,"No base geometry") << endmsg;
  }

  //return _views_b[(layer+SiG->get_layer_count()*(barrel-1))-1]; // cmt.out SFL0_Jan_2005
  if ( bartype == 0 ) // added SFL0_Jan_2005
    return _views_b[(layer+SiG->get_layer_count(0)*(barrel-1))-1]; // added SFL0_Jan_2005
  else if ( bartype == 3 ) {// added SFL0_Jan_2005
    if (ladder==1||ladder==3||ladder==5) layer=1; // added SFL0_Jan_2005
    else layer=2; // added SFL0_Jan_2005
    return _views_l0b[(layer+SiG->get_layer_count(3)*(barrel-1))-1]; // added SFL0_Jan_2005
  }
  ERRLOGTO(theLog,ELfatal,"Invalid barrel type") << endmsg; // added SFL0_Jan_2005
  return -999; // added SFL0_Jan_2005
}


const SiLadderStrips* SiChannelGeometer::get_ladder_strips(int barrel, int layer, int ladder, int view) const // cmt.out SFL0_Jan_2005
{

  unsigned int index = encode(barrel,layer,ladder,view);
  if( _barrel_strips.size() <= index ) return NULL;
  const SiLadderStrips* det = _barrel_strips[index];
  if( det == 0 ) return NULL;
  return det;
  /*
  static SiGeometer* SiG=0;
  if( !SiG ) {
    SiG = SiGeometer::get_instance();
    if( !SiG ) ERRLOGTO(theLog,ELfatal,"No base geometry") << endmsg;
  }

  if( barrel<1 || barrel> SiG->get_barrel_count()) return NULL;
  if( layer<1 || layer> SiG->get_layer_count()) return NULL;
  if( ladder<1 || ladder> SiG->get_ladder_count((layer+SiG->get_layer_count()*(barrel-1))-1)) return NULL;
  if( view<1 || view> _views_b[(layer+SiG->get_layer_count()*(barrel-1))-1]) return NULL;

  int ind_bar=0;

  for (int ib=1; ib<=(barrel-1); ib++) {
    for (int jb=1; jb<=SiG->get_layer_count(); jb++) {
      for (int kb=1; kb<=SiG->get_ladder_count((jb+SiG->get_layer_count()*(ib-1))-1); kb++) {
        ind_bar=ind_bar+_views_b[(jb+SiG->get_layer_count()*(ib-1))-1];
      }
    }
  }

  int ind_lay=0;

  for (int ily=1; ily<=(layer-1); ily++) {
    for (int jly=1; jly<=SiG->get_ladder_count((ily+SiG->get_layer_count()*(barrel-1))-1); jly++) {
      ind_lay=ind_lay+_views_b[(ily+SiG->get_layer_count()*(barrel-1))-1];
    }
  }

  int ind_lad=0;

  for (int ila=1; ila<=(ladder-1); ila++) {
    ind_lad=ind_lad+_views_b[(layer+SiG->get_layer_count()*(barrel-1))-1];
  }

  int istrip = view+ind_lad+ind_lay+ind_bar;

  return _barrel_strips[istrip-1];
  */
}

const SiLadderStrips* SiChannelGeometer::get_ladder_strips(int bartype, int barrel, int layer, int ladder, int view) const // added SFL0_Jan_2005
{

  unsigned int index = encode(barrel,layer,ladder,view);
  //if( _barrel_strips.size() <= index ) return NULL; // cmt.out SFL0_Jan_2005

  const SiLadderStrips* det; // added SFL0_Jan_2005
  if ( bartype == 0 ) { // added SFL0_Jan_2005
    if (  _barrel_strips.size() <= index ) return NULL; // added SFL0_Jan_2005
    //const SiLadderStrips* det = _barrel_strips[index]; // cmt.out SFL0_Jan_2005
    det = _barrel_strips[index]; // added SFL0_Jan_2005
  }
  else if ( bartype == 3 ) { // added SFL0_Jan_2005
    if (  _l0barrel_strips.size() <= index ) return NULL; // added SFL0_Jan_2005
    det = _l0barrel_strips[index]; // added SFL0_Jan_2005
  }

  if( det == 0 ) return NULL;
  return det;
}


const SiWedgeStrips* SiChannelGeometer::get_wedge_strips(int disktype, int disk, int wedge, 
  int view) const 
{
  static SiGeometer* SiG=0;
  if( !SiG ) {
    SiG = SiGeometer::get_instance();
    if( !SiG ) ERRLOGTO(theLog,ELfatal,"No base geometry") << endmsg;
  }

  int istrip;

  if (disktype == 1) { // F disks

     if( disk<1 || disk> SiG->get_disk_count(1)) return NULL;
     if( wedge<1 || wedge> SiG->get_wedgeholder_count(1)) return NULL;
     if( view<1 || view> _views_F) return NULL;

     istrip = view+_views_F*((wedge-1)+SiG->get_wedgeholder_count(1)*(disk-1));
     return _Fdisk_coarse_strips[istrip-1];
  }
  if (disktype == 2) { // H disks
// in H disks two wedges in a wedgeholder are equivalent to the 
// two views of the same object

     if( disk<1 || disk> SiG->get_disk_count(2)) return NULL;
     if( wedge<1 || wedge> SiG->get_wedgeholder_count(2)) return NULL;
     if( view<1 || view> (SiG->get_wedge_count(2)/SiG->get_wedgeholder_count(2))) return NULL;

     istrip = view+(SiG->get_wedge_count(2)/SiG->get_wedgeholder_count(2))*((wedge-1)+SiG->get_wedgeholder_count(2)*(disk-1));
     return _Hdisk_coarse_strips[istrip-1];
  }
  else
   return NULL;
}

const SiWedgeStrips* SiChannelGeometer::get_wedge_strips(int disktype, int disk, int subdisk, int wedge, int view) const
{

  // get the geometer for the ladder/wedge information
  static SiGeometer* SiG=0;
  if( !SiG ) {
    SiG = SiGeometer::get_instance();
    if( !SiG ) ERRLOGTO(theLog,ELfatal,"No base geometry") << endmsg;
  }

  int istrip;

  if (disktype == 1) { // F disks

     if( disk<1 || disk> SiG->get_disk_count(1)) return NULL;
     if( subdisk<1 || subdisk> SiG->get_subdisk_count(1)) return NULL;
     if( wedge<1 || wedge> (SiG->get_wedgeholder_count(1)/SiG->get_subdisk_count(1))) return NULL;
     if( view<1 || view> _views_F) return NULL;

     istrip = view+_views_F*((wedge-1)+(SiG->get_wedgeholder_count(1)/SiG->get_subdisk_count(1))*((subdisk-1)+SiG->get_subdisk_count(1)*(disk-1)));

     return _Fdisk_fine_strips[istrip-1];
  }
  if (disktype == 2) { // H disks
// in H disks two wedges in a wedgeholder are equivalent to the 
// two views of the same object

     if( disk<1 || disk> SiG->get_disk_count(2)) return NULL;
     if( subdisk<1 || subdisk> SiG->get_subdisk_count(2)) return NULL;
     if( wedge<1 || wedge> (SiG->get_wedgeholder_count(2)/SiG->get_subdisk_count(2))) return NULL;
     if( view<1 || view> (SiG->get_wedge_count(2)/SiG->get_wedgeholder_count(2))) return NULL;

     istrip = view+(SiG->get_wedge_count(2)/SiG->get_wedgeholder_count(2))*((wedge-1)+(SiG->get_wedgeholder_count(2)/SiG->get_subdisk_count(2))*((subdisk-1)+SiG->get_subdisk_count(2)*(disk-1)));

     return _Hdisk_fine_strips[istrip-1];
  }
  else
   return NULL;
}


RCP* SiChannelGeometer::check_version(const bool isMC, const int runNumber,
				      const std::vector<std::string>& versions,
				      const edm::Event *anEvt/*0*/)
//
// Purpose: Get the RCP needed for this data.  If no data version is found,
//    use as a default the last version in the map
//
// Arguements:
//
// Returns:
//
{

  int ivers = -1;
  sub_version=0;
  if( _dataVersionGrabber && anEvt ) ivers =_dataVersionGrabber(*anEvt);
  
  // if the version is 3 or more and it's MC we can't trust this version
  // because of all the packing and unpacking stuff
  // so we gonna use supplied list of versions
  if( (ivers >= 3 || ivers == -1) && isMC) {
    // get d0sim versions
    int save = ivers;
    static string empty("");
    const string& version = (versions.size()>1 ? versions[1] : empty );
    // check format
    if( version.size() - empty.size() >= 9 ) { 
      const char* data = version.data();
      bool pass=true;
      if( tolower(data[0]) != 't' && tolower(data[0]) != 'p' ) pass=false;
      if( data[3] != '.' || data[6] != '.'  ) pass=false;
      if( !isdigit(data[1])  || !isdigit(data[2])   ) pass=false;      
      if( !isdigit(data[4])  || !isdigit(data[5])   ) pass=false;      
      if( !isdigit(data[7])  || !isdigit(data[8])   ) pass=false;      
      if( pass ) {
	int ver1= atoi(version.substr(1,3).data());
	int ver2= atoi(version.substr(4,6).data());
	int ver3= atoi(version.substr(7,9).data());
	// test release
	if( tolower(data[0]) == 't' ) {
	  if( ver1*100 + ver2 >= 134 && ver1*100 + ver2 <= 206 ) ivers=3;
	  else if ( ver1*100 + ver2 >= 207 && ver1*100 + ver2 <= 208) ivers=4;
	  else if ( ver1*100 + ver2 >= 209 ) ivers=5;
	  else ivers=2;
	  if( ver1*100 + ver2 < 227 ) sub_version|=2;
	}
	// production release
	if( tolower(data[0]) == 'p' ) {
	  if( ver1 <= 7 ) ivers=2;
	  // preco 03
	  if( ver1 == 3 ) ivers=0;
	  if( ver1 <= 10 ) sub_version|=1;
	  if( ver1*100 + ver2 <  1202 ) sub_version|=2;
	  if( ver1 >= 8 && ver1 <= 11 ) ivers=3;
	  if( ver1 >= 12 ) ivers=5;
	  if( ver1 == 0 && ver2 == 0 && ver3 == 0 ) ivers=save;
	}
      }
    }
  }
  
  // No ability to find smt data chunk or none found.  Return based on default
  if( ivers == (-1) || !isMC ) {
    if( id() == _defaultRCPID ) return 0;
    else return &_versRCPs[_defaultVID];
  }
  
  // An smt data chunk was found.  Can I handle it?
  if( _versRCPs.find(ivers) == _versRCPs.end() ) 
    throw "SiChannelGeometery::check_version, unknown SMT data chunk version.";
  
  // I can handle the found chunk.  Change the version if there's a mismatch.
  if( _versRCPs[ivers].getRCPID() == id() ) return 0;
  else return &_versRCPs[ivers];
}

int SiChannelGeometer::get_version() const {
  std::map<int,edm::RCP>::const_iterator imap;
  for( imap = _versRCPs.begin() ; imap !=_versRCPs.end()  ; ++imap )
    if( imap->second.getRCPID() == id() )
      return imap->first;
  assert(false);
  return -1;
}

SiChannelGeometer::versFuncPtr 
    SiChannelGeometer::smt_data_version_function(versFuncPtr fcn)
{
  versFuncPtr old = _dataVersionGrabber;
  _dataVersionGrabber = fcn;
  return old;
}


// No need for layer0 since it's single-sided // SFL0_Jan_2005
bool SiChannelGeometer::check_ladder_boundaries(int bar,int lyr,int lad,int p_strip,int n_strip,unsigned int map_timestamp) const {
  int address = SmtAddress::Encoder(1,bar,lyr,lad);
  if( map_timestamp == 0 ) {
    Map* map = _maps[get_version()];
    bool stat = map->load_map();
    assert( stat );
    return map->inbounds(address,p_strip,n_strip);
  }
  std::map<int,int>::const_iterator imap;
  for( imap = _timestamps.begin() ; imap !=_timestamps.end()  ; ++imap )
    if( imap->second == map_timestamp ) {
      Map* map = _maps[imap->first];
      bool stat = map->load_map();
      assert( stat );
      return map->inbounds(address,p_strip,n_strip);
    }
  cerr<<"Unable to find a map file with timestmap "<<map_timestamp<<"\n";
  assert(false);
  return false;
}

bool SiChannelGeometer::check_wedge_boundaries(int disktype,int disk,int wedge,int p_strip,int n_strip,unsigned int map_timestamp) const {
  int address = SmtAddress::Encoder(disktype+1,disk,wedge);
  if( map_timestamp == 0 ) {
    Map* map = _maps[get_version()];
    bool stat = map->load_map();
    assert( stat );
    return map->inbounds(address,p_strip,n_strip);
  }
  std::map<int,int>::const_iterator imap;
  for( imap = _timestamps.begin() ; imap !=_timestamps.end()  ; ++imap )
    if( imap->second == map_timestamp ) {
      Map* map = _maps[imap->first];
      bool stat = map->load_map();
      assert( stat );
      return map->inbounds(address,p_strip,n_strip);
    }
  cerr<<"Unable to find a map file with timestmap "<<map_timestamp<<"\n";
  assert(false);
  return false;
}

unsigned int SiChannelGeometer::get_map_timestamp() const {
  Map* map = _maps[get_version()];
  bool stat = map->load_map();
  assert( stat ) ;
  return map->get_timestamp();
}

int SiChannelGeometer::get_subversion() const {
  return sub_version;
}

namespace {
void clear_maps(std::map<int,silicon_geom::Map*> maps) {
  std::map<int,silicon_geom::Map*>::const_iterator imap;
  for(imap=maps.begin();imap!=maps.end();imap++) {
    imap->second->clear_map();
  }
}
}