//
// $Id: SiBaseGeometryRCP.cpp,v 1.19 2005/04/03 15:36:36 shfu Exp $
//
// File: SiBaseGeometry_RCP.cpp
// Purpose: Implement the RCP-parameter gathering classes for the silicion
//          detector instantiation.   These are (initially) used only in 
//
//                      SiBaseGeometry::build_silicon
//
// Created: 07-NOV-1997   John Hobbs
//
// Jan 31, 2005 by Shaohua Fu
// added Layer0 // SFL0_Jan_2005
//
// $Revision: 1.19 $
//

// Include files
#include <string>
#include <iostream>
#include <vector>
#include <rcp/RCP.hpp>
#include "SiBaseGeometryRCP.hpp"
//#include "SiLadder.hpp"
//#include "SiLayer.hpp"
//#include "SiBarrel.hpp"
#include "SiCenter.hpp"
#include "SiEnd.hpp"
#include "d0_util/formatting.hpp"
#include "SiL0.hpp" // added SFL0_Jan_2005


using namespace std;
using namespace dgs;
using namespace edm;

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

// A temporary kludge for converting a string to a char *.  Convert to
// string to string for temporary testing...
static string stoc(const string s) { return s; }

// Constructors/Destructors
SiLadderType::SiLadderType(const RCP& RCPinit, int id) 
{
  const string basename = "ld"+itoa(id)+"_";
  _halfwidth = RCPinit.getFloat(basename+"hwidth");
  _halflength = RCPinit.getFloat(basename+"hlength");
  _halfthick =  RCPinit.getFloat(basename+"hthick");
  float alength = RCPinit.getFloat(basename+"alength");
  float awidth = RCPinit.getFloat(basename+"awidth");
  float calength = RCPinit.getFloat(basename+"alcenter");
  float cawidth = RCPinit.getFloat(basename+"awcenter");

  _an_instance = SiLadder(_halfwidth,_halflength,alength,awidth,calength,cawidth);
}

SiLayerType::SiLayerType(const RCP& RCPinit, int id,
			 const vector<SiLadderType>* ladders)
{
  const string basename = "ly"+itoa(id)+"_";
  _nladders = RCPinit.getInt(basename+"nladders");
  _radius = RCPinit.getFloat(basename+"radius");
  _zhalf = RCPinit.getFloat(basename+"zhalf");
  _phi0 = RCPinit.getFloat(basename+"phi0");
  _ladder_sense = RCPinit.getBool(basename+"ladder_flip");
  _ladder_type = RCPinit.getInt(basename+"ladder_type");
  _zpos = RCPinit.getFloat(basename+"zpos");

  // If ladders exist, create an instance of this layer..
  if( ladders ) {
    if( ladders->size()>=_ladder_type ) {
      const SiLadder* theLadder = (*ladders)[_ladder_type-1].instance();
      if( theLadder ) _an_instance = SiLayer(_radius,_zhalf,_nladders,_phi0,
					     _zpos,_ladder_sense,theLadder);
      else std::cerr << "ERROR: No instance for ladder id = " << _ladder_type << endl;
    }
    else  std::cerr << "ERROR: Requested ladder = " << _ladder_type
	       << " out-of-range" << endl;
  }
}

SiBarrelType::SiBarrelType(const RCP& RCPinit,int id, 
			   const vector<SiLayerType>* layers)
{
  const string basename = "b"+itoa(id)+"_";
  int nlayers = RCPinit.getInt(stoc(basename+"nlayers"));
  _spun =  RCPinit.getBool(stoc(basename+"spun"));

  // Get the layer type indices...
  for( int i=0 ; i<nlayers ; i++ )
    _layer_types.push_back(RCPinit.getInt(stoc(basename+"layer_type"+itoa(i+1))));

  // If layers exist, use them to make a prototype instance...
  if( layers && layers->size() > 0 ) {
    vector<SiLayer> mylayers;
    for(int i=0 ; i<_layer_types.size() ; i++ ) {
      int idlayer = _layer_types[i];
      if( idlayer>0 && idlayer<=layers->size() ) {
	const SiLayer* requestedLayer = (*layers)[idlayer-1].instance();
	if( requestedLayer ) mylayers.push_back(*requestedLayer); 
	else std::cerr << " NULL pointer returned for requested layer = " << idlayer
		  << endl;
      }
      else std::cerr << "ERROR: Requested layer = " << idlayer << " out-of-range"
		<< endl;
    }
    _an_instance = SiBarrel(mylayers,_spun);
  }

}

SiWedgeType::SiWedgeType(const RCP& RCPinit, int id) 
{
  const string basename = "w"+itoa(id)+"_";
  _halfwidth1 = RCPinit.getFloat(stoc(basename+"hwidth1"));
  _halfwidth2 = RCPinit.getFloat(stoc(basename+"hwidth2"));
  _halfheight = RCPinit.getFloat(stoc(basename+"hheight"));
  float act_halfwidth1 = RCPinit.getFloat(stoc(basename+"awidth1"));
  float act_halfwidth2 = RCPinit.getFloat(stoc(basename+"awidth2"));
  float act_halfheight = RCPinit.getFloat(stoc(basename+"aheight"));
  float act_center =  RCPinit.getFloat(stoc(basename+"acenter"));
  _an_instance = SiWedge(_halfwidth1,_halfwidth2,_halfheight,act_halfwidth1,act_halfwidth2,act_halfheight,act_center);
}

SiWedgeHolderType::SiWedgeHolderType(const RCP& RCPinit, int id,
			 const vector<SiWedgeType>* wedges)
{
  const string basename = "wh"+itoa(id)+"_";
  int nwedges = RCPinit.getInt(stoc(basename+"nwedges"));
  _dhoffs = RCPinit.getFloat(stoc(basename+"dhoffs"));


  // Get the wedge type indices...
  for( int i=0 ; i<nwedges ; i++ )
    _wedge_types.push_back(RCPinit.getInt(stoc(basename+"wedge_type"+itoa(i+1))));

  // If wedges exist, use them to make an prototype instance...
  if( wedges && wedges->size() > 0 ) {
    vector<SiWedge> mywedges;
    for(int i=0 ; i<_wedge_types.size() ; i++ ) {
      int idwedge = _wedge_types[i];

      if( idwedge>0 && idwedge<=wedges->size() ) {
	const SiWedge* requestedWedge = (*wedges)[idwedge-1].instance();
	if( requestedWedge ) mywedges.push_back(*requestedWedge); 
	else std::cerr << " NULL pointer returned for requested wedge = " << idwedge
		  << endl;
      }
      else std::cerr << "ERROR: Requested wedge = " << idwedge << " out-of-range"
		<< endl;
    }
    _an_instance = SiWedgeHolder(_wedge_types.size(),mywedges,_dhoffs);
  }

}

SiDiskType::SiDiskType(const RCP& RCPinit, int id,
			 const vector<SiWedgeHolderType>* wedgeholders)
{
  const string basename = "d"+itoa(id)+"_";
  _nwedgeholders = RCPinit.getInt(stoc(basename+"nwholders"));
  _radius = RCPinit.getFloat(stoc(basename+"radius"));
  _separation = RCPinit.getFloat(stoc(basename+"separation"));
  _phi0 = RCPinit.getFloat(stoc(basename+"phi0"));
  _phi1 = RCPinit.getFloat(stoc(basename+"phi1"));
  _wedgeholder_sense = RCPinit.getBool(stoc(basename+"wedgeholder_flip"));
  _wedgeholder_type = RCPinit.getInt(stoc(basename+"wedgeholder_type"));
  _disk_flip = RCPinit.getBool(stoc(basename+"disk_flip"));

  // If wedgeholders exist, use them to make a prototype instance...
  if( wedgeholders && wedgeholders->size() > 0 ) {
    vector<SiWedgeHolder> mywedgeholders;
    for(int i=0 ; i<_nwedgeholders ; i++ ) {
      int idwedgeholder = _wedgeholder_type;
      if( idwedgeholder>0 && idwedgeholder<=wedgeholders->size() ) {
	const SiWedgeHolder* requestedWedgeHolder = (*wedgeholders)[idwedgeholder-1].instance();
	if( requestedWedgeHolder ) mywedgeholders.push_back(*requestedWedgeHolder); 
	else std::cerr << " NULL pointer returned for requested wedgeholder = " << idwedgeholder
		  << endl;
      }
      else std::cerr << "ERROR: Requested wedgeholder = " << idwedgeholder << " out-of-range"
		<< endl;
    }
    _an_instance = SiDisk(_radius,_nwedgeholders,_phi0, _wedgeholder_sense, mywedgeholders,_phi1, _separation, _disk_flip);
  }
}

SiCentralType::SiCentralType(const RCP& RCPinit,int id, 
			   const vector<SiBarrelType>* barrels,
			   const vector<SiDiskType>* disks)
{
  const string basename = "ce"+itoa(id)+"_";

  // Get the barrel type indices and z positions, same for the disks...
  int i;
  int nbarrels = RCPinit.getInt(stoc(basename+"nbarrels"));
  for( i=0; i<nbarrels ; i++ ) {
    string is = itoa(i+1);
    _barrel_types.push_back(RCPinit.getInt(stoc(basename+"barrel_type"+is)));
    _barrel_zs.push_back(RCPinit.getFloat(stoc(basename+"barrel_z"+is)));
  }
  int ndisks = RCPinit.getInt(stoc(basename+"ndisks"));
  for( i=0; i<ndisks ; i++ ) {
    string is = itoa(i+1);
    _disk_types.push_back(RCPinit.getInt(stoc(basename+"disk_type"+is)));
    _disk_zs.push_back(RCPinit.getFloat(stoc(basename+"disk_z"+is)));
  }

  // If barrels and disks exist, use them to make an prototype instance...
  if( barrels && barrels->size() > 0 && disks && disks->size() > 0 ) {
    vector<SiBarrel> theBarrels;
    vector<SiDisk>   theDisks;

    for( i=0; i<_barrel_types.size() ; i++ ) {
      if (_barrel_types[i]<=barrels->size() ) {
	const SiBarrel* thisBarrel = (*barrels)[_barrel_types[i]-1].instance();
	if( thisBarrel ) theBarrels.push_back(*thisBarrel);
	else std::cerr << " NULL pointer returned for requested barrel "
		  << _barrel_types[i] << endl;
      }
      else std::cerr << "ERROR: Requested barrel = " << _barrel_types[i] 
		<< " out-of-range" << endl;
    }

    for( i=0 ; i<_disk_types.size() ; i++ ) {
      if( _disk_types[i]<=disks->size() ) {
	const SiDisk* thisDisk = (*disks)[_disk_types[i]-1].instance();
	if( thisDisk ) theDisks.push_back(*thisDisk);
	else std::cerr << " NULL pointer returned for requested disk "
		  << _disk_types[i] << endl;
      }
      else std::cerr << "ERROR: Requested disk = " << _disk_types[i] 
		<< " out-of-range" << endl;
    }

    _an_instance = SiCentral(_barrel_zs, theBarrels, _disk_zs, theDisks);
  }
}

SiCenterType::SiCenterType(const RCP& RCPinit,int id, 
			   const vector<SiCentralType>* centrals)
{
  int i;
  const string basename = "c"+itoa(id)+"_";
  int ncentrals = RCPinit.getInt(stoc(basename+"ncentrals"));

  // Get the central type indices and zs...
  for( i=0 ; i<ncentrals ; i++ ) {
    _central_types.push_back(RCPinit.getInt(stoc(basename+"central_type"+itoa(i+1))));
    _central_zs.push_back(RCPinit.getFloat(stoc(basename+"central_z"+itoa(i+1))));
  }

  // If centrals exist, use them to make a prototype instance...
  if( centrals && centrals->size() > 0 ) {
    vector<SiCentral> mycentrals;
    for( i=0 ; i<_central_types.size() ; i++ ) {
      int idcentral = _central_types[i];
      if( idcentral>0 && idcentral<=centrals->size() ) {
	const SiCentral* requestedCentral = (*centrals)[idcentral-1].instance();
	if( requestedCentral ) mycentrals.push_back(*requestedCentral); 
	else std::cerr << " NULL pointer returned for requested central = " << idcentral << endl;
      }
      else std::cerr << "ERROR: Requested central = " << idcentral << " out-of-range"
		<< endl;
    }
    _an_instance = SiCenter(mycentrals,_central_zs);
  }

}



SiEndType::SiEndType(const RCP& RCPinit,int id, 
			   const vector<SiDiskType>* disks)
{
  const string basename = "end"+itoa(id)+"_";
  int ndisks = RCPinit.getInt(stoc(basename+"ndisks"));

  // Get the disk type indices and zs...
  for( int i=0 ; i<ndisks; i++ ) {
    _disk_types.push_back(RCPinit.getInt(stoc(basename+"disk_type"+itoa(i+1))));
    _disk_zs.push_back(RCPinit.getFloat(stoc(basename+"disk_z"+itoa(i+1))));
  }
  // If disks exist, use them to make an prototype instance...
  if( disks && disks->size() > 0 ) {
    vector<SiDisk> mydisks;
    for(int i=0 ; i<_disk_types.size() ; i++ ) {
      int iddisk = _disk_types[i];
      if( iddisk>0 && iddisk<=disks->size() ) {
	const SiDisk* requestedDisk = (*disks)[iddisk-1].instance();
	if( requestedDisk ) mydisks.push_back(*requestedDisk); 
	else std::cerr << " NULL pointer returned for requested disk = " << iddisk << endl;
      }
      else std::cerr << "ERROR: Requested disk = " << iddisk << " out-of-range"
		<< endl;
    }
    _an_instance = SiEnd(_disk_types.size(), _disk_zs, mydisks);
  }

}



// added SFL0_Jan_2005
SiL0Type::SiL0Type(const RCP& RCPinit,int id, 
		   const vector<SiBarrelType>* barrels)
{
  const string basename = "l0"+itoa(id)+"_";
  int nbarrels = RCPinit.getInt(stoc(basename+"nbarrels"));

  // Get the barrel type indices and zs...
  for( int i=0 ; i<nbarrels ; i++ ) {
    _barrel_types.push_back(RCPinit.getInt(stoc(basename+"barrel_type"+itoa(i+1))));
    _barrel_zs.push_back(RCPinit.getFloat(stoc(basename+"barrel_z"+itoa(i+1))));
  }
  // If barrels exist, use them to make an prototype instance...
  if( barrels && barrels->size() > 0 ) {
    vector<SiBarrel> mybarrels;
    for(int i=0 ; i<_barrel_types.size() ; i++ ) {
      int idbarrel = _barrel_types[i];
      if( idbarrel>0 && idbarrel<=barrels->size() ) {
	const SiBarrel* requestedBarrel = (*barrels)[idbarrel-1].instance();
	if( requestedBarrel ) mybarrels.push_back(*requestedBarrel); 
	else std::cerr << " NULL pointer returned for requested barrel = " << idbarrel << endl;
      }
      else std::cerr << "ERROR: Requested barrel = " << idbarrel << " out-of-range"
		<< endl;
    }
    _an_instance = SiL0(_barrel_types.size(), _barrel_zs, mybarrels);
  }

}
// end of SFL0_Jan_2005