#include "PndSttMapCreator.h"
#include "PndSttTube.h"
#include "PndGeoSttPar.h"

#include "FairGeoNode.h"
#include "FairGeoTransform.h"
#include "FairGeoVector.h"
#include "FairGeoRotation.h"
#include "FairGeoTube.h"

#include "TGeoTube.h"
#include "TVector3.h"
#include "TObjArray.h"
#include "TString.h"
#include "TGeoVolume.h"
#include "TGeoTube.h"
#include "TClonesArray.h"

#include <iostream>

using namespace std;

PndSttMapCreator::PndSttMapCreator(){}

// to use in PndStt
PndSttMapCreator::PndSttMapCreator(Int_t geoType){
  fGeoType = geoType;
  //  if(fGeoType == 1) SetGeometryParameters();        // CHECK
  if(fGeoType != 1) cout << "geometry not supported by map" << endl; // CHECK
}

// crete geometry from parameters file
PndSttMapCreator::PndSttMapCreator(PndGeoSttPar *sttPar)
{
  fSttParameters = sttPar;
  // set general par
  SetGeneralParameters();
  // choose geometry type
  fGeoType = sttPar->GetGeometryType(); // classic, optimized, average, detailed, CAD
  if(fGeoType == 1) SetGeometryParameters(sttPar);
  else cout << "geometry not supported by map" << endl; // CHECK
}

PndSttMapCreator::~PndSttMapCreator(){}

void PndSttMapCreator::SetGeneralParameters() {   //  CHECK whether it depends on geometry or not
  fTubeInRad = fSttParameters->GetTubeInRad();   // tube inner radius
  fTubeOutRad = fSttParameters->GetTubeOutRad(); // tube outer radius
}

void PndSttMapCreator::SetGeometryParameters(PndGeoSttPar *sttPar) {
  
 if(fGeoType == 1) {
   fNLayers = sttPar->GetNLayers();
   fNSectors = sttPar->GetNSectors();
   fNTubes = sttPar->GetNTubes();
   fNTubes_inner_parallel = sttPar->GetNTubes_inner_parallel();
   fNTubes_outer_parallel = sttPar->GetNTubes_outer_parallel();
   fNTubes_fillup_parallel = sttPar->GetNTubes_fillup_parallel();
   fNTubes_skewed = sttPar->GetNTubes_skewed();
   fNLayers_inner_parallel = sttPar->GetNLayers_inner_parallel();
   fNLayers_outer_parallel = sttPar->GetNLayers_outer_parallel();
   fNLayers_fillup_parallel = sttPar->GetNLayers_fillup_parallel();
   TArrayI limitList = sttPar->GetLimitList();
   TArrayI shiftList = sttPar->GetShiftList();

   fStartTube = (int**) malloc(sizeof(int*) * fNSectors);
   fEndTube   = (int**) malloc(sizeof(int*) * fNSectors);
   fShift = (int**) malloc(sizeof(int*) * fNSectors);
   for(int i = 0; i < fNSectors; i++) {
     fStartTube[i] = (int*) malloc(sizeof(int*) * fNLayers);
     fEndTube[i] = (int*) malloc(sizeof(int*) * fNLayers);
     fShift[i] = (int*) malloc(sizeof(int*) * fNLayers);
   }

   // --------- fStartTube ---------
   int isector = 0, ilayer = 0;
   for(int i = 0; i < fNLayers * fNSectors; i++) {
     if(ilayer == fNLayers) {
       isector++;
       ilayer = 0;
     }
     fStartTube[isector][ilayer] = limitList[i];
     ilayer++;  
   }

   // --------- fShift ---------
   for(int j = 0; j < 2 * fNLayers; j++) {
     if(j < fNLayers) {
        fShift[0][j] = shiftList[j];
        fShift[3][j] = shiftList[j];
     }
     else  {
        fShift[1][j - fNLayers] = shiftList[j];
        fShift[2][j - fNLayers] = shiftList[j];
        fShift[4][j - fNLayers] = shiftList[j];
        fShift[5][j - fNLayers] = shiftList[j];
     }
   }

   // --------- fEndtTube ---------
   for(isector = 0; isector < fNSectors; isector++) {
     for(ilayer = 0; ilayer <  fNLayers; ilayer++) {
       if(isector == fNSectors - 1) {
	 if(ilayer == fNLayers_inner_parallel - 1) fEndTube[isector][ilayer] = fNTubes_inner_parallel;
	 else if(ilayer == fNLayers_inner_parallel + fNLayers_outer_parallel - 1) fEndTube[isector][ilayer] =  fNTubes_inner_parallel + + fNTubes_skewed + fNTubes_outer_parallel;
	 else if(ilayer == fNLayers_inner_parallel + fNLayers_outer_parallel + fNLayers_fillup_parallel - 1) fEndTube[isector][ilayer] =  fNTubes_inner_parallel + fNTubes_outer_parallel + fNTubes_skewed + fNTubes_fillup_parallel;
	 else fEndTube[isector][ilayer] = fStartTube[0][ilayer + 1] - 1;
       }
       else {
	 //   cout << isector << " " << ilayer << " " << fStartTube[isector + 1][ilayer] << endl;
	 fEndTube[isector][ilayer] = fStartTube[isector + 1][ilayer] - 1;
       }
     }
   }
   
 }
 return ;
   /**
     if(fGeoType == 1) {
     ifstream in;	
     in.open("./parameters.ascii");

     //  cout << "in.good " << in.good() << endl;

     while (in.good()) {
     in >> fNTubes_inner_parallel >> fNTubes_outer_parallel >> fNTubes_fillup_parallel >> fNTubes_skewed;
    
     fNTubes = fNTubes_inner_parallel + fNTubes_outer_parallel + fNTubes_fillup_parallel + fNTubes_skewed;
    
     in >> fNLayers_inner_parallel >> fNLayers_outer_parallel >> fNLayers_fillup_parallel;
     fNLayers = fNLayers_inner_parallel + fNLayers_outer_parallel + fNLayers_fillup_parallel;
    
     in >> fNSectors;
     //    cout <<  fNTubes_inner_parallel << " " <<  fNTubes_outer_parallel << " " << fNTubes_fillup_parallel << " " << fNTubes_skewed << endl;
     //    cout << fNLayers_inner_parallel << " " << fNLayers_outer_parallel << " " << fNLayers_fillup_parallel << endl;
     //    cout << fNSectors << endl;
     fStartTube = (int**) malloc(sizeof(int*) * fNSectors);
     fEndTube   = (int**) malloc(sizeof(int*) * fNSectors);
     fShift = (int**) malloc(sizeof(int*) * fNSectors);
     for(int i = 0; i < fNSectors; i++) {
     fStartTube[i] = (int*) malloc(sizeof(int*) * fNLayers);
     fEndTube[i] = (int*) malloc(sizeof(int*) * fNLayers);
     fShift[i] = (int*) malloc(sizeof(int*) * fNLayers);
     }
    
     int isector = 0, ilayer = 0;
     for(int i = 0; i < fNLayers * fNSectors; i++) {
     if(ilayer == fNLayers) {
     isector++;
     ilayer = 0;
     }
     in >> fStartTube[isector][ilayer];
     //      cout << ilayer << " " << isector << " " <<  fStartTube[isector][ilayer] << endl;
     ilayer++;  
     }
     //     cout << "_---------------------------------------" << endl;
     //     for(isector = 0; isector < fNSectors; isector++) {
     //       for(ilayer = 0; ilayer <  fNLayers; ilayer++) {
     // 	cout << " " << fStartTube[isector][ilayer];
     //       }
     //       cout << endl;
     //     }
    
     int shift_value;
  
     for(int j = 0; j < fNLayers; j++) {
     in >> shift_value;
     fShift[0][j] = shift_value;
     fShift[3][j] = shift_value;
     }
     for(int j = 0; j < fNLayers; j++) {
     in >> shift_value;
     for(int i = 0; i < fNSectors; i++) if(i != 0 && i != 3) fShift[i][j] = shift_value;
     }
     }
     //    for(int isector = 0; isector < fNSectors; isector++) {
     //     for(int ilayer = 0; ilayer <  fNLayers; ilayer++) {
     //       cout << " " <<  fShift[isector][ilayer];
     //     }
     //     cout << endl;
     //  }
     for(int isector = 0; isector < fNSectors; isector++) {
     for(int ilayer = 0; ilayer <  fNLayers; ilayer++) {
     if(isector == fNSectors - 1) {
     if(ilayer == fNLayers_inner_parallel - 1) fEndTube[isector][ilayer] = fNTubes_inner_parallel;
     else if(ilayer == fNLayers_inner_parallel + fNLayers_outer_parallel - 1) fEndTube[isector][ilayer] =  fNTubes_inner_parallel + + fNTubes_skewed + fNTubes_outer_parallel;
     else if(ilayer == fNLayers_inner_parallel + fNLayers_outer_parallel + fNLayers_fillup_parallel - 1) fEndTube[isector][ilayer] =  fNTubes_inner_parallel + fNTubes_outer_parallel + fNTubes_skewed + fNTubes_fillup_parallel;
     else fEndTube[isector][ilayer] = fStartTube[0][ilayer + 1] - 1;
     }
     else {
     //   cout << isector << " " << ilayer << " " << fStartTube[isector + 1][ilayer] << endl;
     fEndTube[isector][ilayer] = fStartTube[isector + 1][ilayer] - 1;
     }
     }
     }
     //  for(int isector = 0; isector < fNSectors; isector++) {
     //     for(int ilayer = 0; ilayer <  fNLayers; ilayer++) {
     //       cout << " " <<  fEndTube[isector][ilayer];
     //     }
     //     cout << endl;
     //  }
     }
     return ;
  **/
}

void PndSttMapCreator::Print() {

  cout << "geometry type " << fGeoType << endl;
  cout << "tubes inner/outer/fillup/skew " << fNTubes_inner_parallel << " " <<  fNTubes_outer_parallel << " " << fNTubes_fillup_parallel << " " << fNTubes_skewed << endl;
  cout << "layers inner/outer/fillup/skew " << fNLayers_inner_parallel << " " << fNLayers_outer_parallel << " " << fNLayers_fillup_parallel << endl;
  cout << "sectors " << fNSectors << endl;
  
  cout << "start tubes ---------------------------------------" << endl;
  for(int isector = 0; isector < fNSectors; isector++) {
    for(int ilayer = 0; ilayer <  fNLayers; ilayer++) {
      cout << " " << fStartTube[isector][ilayer];
    }
    cout << endl;
  }
  
  cout << "shift ---------------------------------------" << endl;
  for(int isector = 0; isector < fNSectors; isector++) {
    for(int ilayer = 0; ilayer <  fNLayers; ilayer++) {
      cout << " " <<  fShift[isector][ilayer];
    }
    cout << endl;
  }

  cout << "end tubes ---------------------------------------" << endl;
  for(int isector = 0; isector < fNSectors; isector++) {
    for(int ilayer = 0; ilayer <  fNLayers; ilayer++) {
      cout << " " <<  fEndTube[isector][ilayer];
    }
    cout << endl;
  }
}

// during simulation
Int_t PndSttMapCreator::GetTubeIDFromPath(TString path) {
  if(fGeoType == 1) return GetTubeIDFromPathGeoType1(path);
  return -999;
}

// during parameters reading
Int_t PndSttMapCreator::GetTubeIDFromName(TString name){
  if(fGeoType == 1) return GetTubeIDFromNameGeoType1(name);
  return -999;
}

// retrieve parameters from tube ID
PndSttTube * PndSttMapCreator::GetTubeFromTubeID(Int_t tubeid) {
  if(fGeoType == 1) return GetTubeFromTubeIDGeoType1(tubeid);
  return NULL;
}

// fill the tube map at the beginning of the run
TClonesArray * PndSttMapCreator::FillTubeArray() {
  if(fGeoType == 1) return FillTubeArrayGeoType1();
  return NULL;
}

TString PndSttMapCreator::GetNameFromTubeID(Int_t tubeid) {
  PndSttTube *tube = GetTubeFromTubeID(tubeid);
  if(!tube) return "NULL";        
 
  return tube->GetName();
  //   if(fGeoType == 1) return GetNameFromTubeIDGeoType1(tubeid); // this can' t work without the difference copy/solo anymore
}

// ===== GEO TYPE 1 =====
// sensitive volume is gas 
// when reading the parameters we use stt01tube to retrieve geometrical information

// OK
// during simulation
Int_t PndSttMapCreator::GetTubeIDFromPathGeoType1(TString path){
  TString tmpstring = GetNameFromPathGeoType1(path);
  return GetTubeIDFromNameGeoType1(tmpstring);
}

// OK
Int_t PndSttMapCreator::GetTubeIDFromNameGeoType1(TString name){
  // two possibilities: we DON' T CARE and just take the XXX part
  // copy : stt01tube#XXX  --> XXX
  // solo : stt01tubeXXX --> XXX   
 
  TString tmpstring = name;

  if(tmpstring.Contains("#")) {
    int start = tmpstring.Index("#") + 1;
    tmpstring = tmpstring(start, tmpstring.Sizeof());
  } 
  else{
    int start = tmpstring.Index("e") + 1;
    tmpstring = tmpstring(start, tmpstring.Sizeof());
  }
  return tmpstring.Atoi();
}

// OK
// name as in geo file: from path "_" to name "#"
TString PndSttMapCreator::GetNameFromPathGeoType1(TString path){
  // two possibilities:
  // copy : /cave_1/stt01assembly_0/stt01tube_XXX/stt01gas_1     --> stt01tube#XXX
  // solo : /cave_1/stt01assembly_0/stt01tubeXXX_0/stt01gasXXX_0 --> stt01tubeXXX

  TString tmpstring = path;

  // cut /cave_1/stt01assembly_0/
  TString cavename;
  cavename = "/cave_1/stt01assembly_0/";
  tmpstring = tmpstring(cavename.Sizeof() - 1, tmpstring.Sizeof());
 
  // cut /stt01gas...
  int index = tmpstring.Index("/");
  tmpstring = tmpstring(0, index);

  // replace _ with #
  if(tmpstring.Contains("_0")) {
    tmpstring.Chop(); // cut "0"
    tmpstring.Chop(); // cut "_"
  }
  else{
    tmpstring.Replace(9, 1, "#");
  }

  return tmpstring;
}

// OK
// name "#"
TString PndSttMapCreator::GetNameFromTubeIDGeoType1(Int_t tubeid, Bool_t isCopy) {

  // two possibilities:
  // copy : XXX --> stt01tube#XXX  
  // solo : XXX --> stt01tubeXXX

  TString tmpstring; 
  tmpstring += tubeid ;

  if(isCopy == kTRUE) {
    tmpstring.Prepend("stt01tube#");
  }
  else {
    tmpstring.Prepend("stt01tube");
  }
  return tmpstring;

}

// OK
PndSttTube * PndSttMapCreator::GetTubeFromTubeIDGeoType1(Int_t tubeid) {

  TObjArray *geoPassNodes = fSttParameters->GetGeoPassiveNodes();

  Bool_t isCopy = copy_map[tubeid];
  TString tubename  = GetNameFromTubeIDGeoType1(tubeid, isCopy);
  FairGeoNode *pnode  = (FairGeoNode*) geoPassNodes->FindObject(tubename);
  
  if(!pnode) {
    cout << "PndSttMapCreator::GetTubeFromTubeIDGeoType1: tube " << tubename << " not found (nor as a copy)" << endl; 
    return NULL;
  }
      
  FairGeoTransform *lab = pnode->getLabTransform();
  FairGeoVector     tra = lab->getTransVector();
  FairGeoRotation   rot = lab->getRotMatrix();
  
  // geometrical info
  double x = tra.getX()/10.; // in cm
  double y = tra.getY()/10.; // in cm
  double z = tra.getZ()/10.; // in cm
  double r[3][3];
  for(int i = 0; i < 3; i++)for(int j = 0; j < 3; j++) r[i][j] = rot.getElement(i,j);
  
  TGeoVolume* rootvol = pnode->getRootVolume();
  TGeoTube *tube = (TGeoTube*) rootvol->GetShape();
  Double_t halflength = tube->GetDz(); // in cm
  
  // sets up the correspondence int (tubeID) <--> int (1 = copy/0 = solo)
  //  copy_map[key] = alloc
  copy_map[tubeid] = isCopy;
  int sectorid = GetTubeSectorGeoType1(tubeid);
  int layerid = GetTubeLayerGeoType1(tubeid);

  return new PndSttTube(tubeid, sectorid, layerid,
			(float)x,(float)y,(float)z,  
			r[0][0],r[0][1],r[0][2],
			r[1][0],r[1][1],r[1][2],
			r[2][0],r[2][1],r[2][2],
			fTubeInRad, fTubeOutRad, halflength);
}

// OK
PndSttTube * PndSttMapCreator::GetTubeFromTubeIDToFillGeoType1(Int_t tubeid) {

  TObjArray *geoPassNodes = fSttParameters->GetGeoPassiveNodes();

  Bool_t isCopy = kTRUE;

  // try as if it was a copy stt01tube#XXX
  TString  tubename = GetNameFromTubeIDGeoType1(tubeid, isCopy);
  FairGeoNode *pnode = (FairGeoNode*) geoPassNodes->FindObject(tubename);
  
  if(!pnode) { // try as if it was a solo stt01tubeXXX
    isCopy = kFALSE;
    tubename = GetNameFromTubeIDGeoType1(tubeid, isCopy);
    pnode = (FairGeoNode*) geoPassNodes->FindObject(tubename);
  }

  if(!pnode) {
    cout << "PndSttMapCreator::GetTubeFromTubeIDToFillGeoType1: tube " << tubename << " not found (nor as a copy)" << endl; 
    return NULL;
  }
      
  FairGeoTransform *lab = pnode->getLabTransform();
  FairGeoVector     tra = lab->getTransVector();
  FairGeoRotation   rot = lab->getRotMatrix();
  
  // geometrical info
  double x = tra.getX()/10.; // in cm
  double y = tra.getY()/10.; // in cm
  double z = tra.getZ()/10.; // in cm
  double r[3][3];
  for(int i = 0; i < 3; i++)for(int j = 0; j < 3; j++) r[i][j] = rot.getElement(i,j);
  
  TGeoVolume* rootvol = pnode->getRootVolume();
  TGeoTube *tube = (TGeoTube*) rootvol->GetShape();
  Double_t halflength = tube->GetDz(); // in cm
  
  // sets up the correspondence int (tubeID) <--> int (1 = copy/0 = solo)
  //  copy_map[key] = alloc
  copy_map[tubeid] = isCopy;
  int sectorid = GetTubeSectorGeoType1(tubeid);
  int layerid = GetTubeLayerGeoType1(tubeid);
  
  return new PndSttTube(tubeid, sectorid, layerid,
			(float)x,(float)y,(float)z,  
			r[0][0],r[0][1],r[0][2],
			r[1][0],r[1][1],r[1][2],
			r[2][0],r[2][1],r[2][2],
			fTubeInRad, fTubeOutRad, halflength);
}

TClonesArray* PndSttMapCreator::FillTubeArrayGeoType1() { 
  
  TObjArray *geoPassNodes = fSttParameters->GetGeoPassiveNodes();
  TClonesArray *tubeArray = new TClonesArray("PndSttTube");
  tubeArray->Delete();
  for(int i = 0; i < geoPassNodes->GetEntriesFast(); i++) {
    FairGeoNode *pnode = (FairGeoNode*) geoPassNodes->At(i);
    if(!pnode) continue;
    TString tubename = pnode->GetName();
    if(!tubename.Contains("stt01tube")) continue;
    Int_t tubeID = GetTubeIDFromNameGeoType1(tubename);

    PndSttTube *stttube = GetTubeFromTubeIDToFillGeoType1(tubeID); 
    stttube->SetTubeID(tubeID);
    stttube->SetLayerID(GetTubeLayerGeoType1(tubeID));
    stttube->SetSectorID(GetTubeSectorGeoType1(tubeID));

    // correspondance position in TCA <-> tubeID
    new((*tubeArray)[tubeID]) PndSttTube(*stttube);
  }

  return tubeArray;
}


Int_t PndSttMapCreator::GetTubeLayerGeoType1(int tubeid) {
  for(int ilayer = 0; ilayer < fNLayers; ilayer++) { 
    if(tubeid >= fStartTube[0][ilayer] && tubeid <= fEndTube[5][ilayer]) return ilayer;
  }
  return -1;
}

Int_t PndSttMapCreator::GetTubeSectorGeoType1(int tubeid) {
  Int_t ilayer = GetTubeLayerGeoType1(tubeid);
  if(ilayer == -1) return -1;
  for(int isector = 0; isector < fNSectors; isector++) { 
    if(tubeid >= fStartTube[isector][ilayer] && tubeid <= fEndTube[isector][ilayer]) return isector;
  }
  return -1;
}

TArrayI PndSttMapCreator::ComputeNeighboringGeoType1(Int_t tubeID) {
  Int_t sectorID = GetTubeSectorGeoType1(tubeID);
  Int_t layerID = GetTubeLayerGeoType1(tubeID);

  
  bool fillup = false;
  if(layerID > fNLayers_inner_parallel + fNLayers_outer_parallel) fillup = true;

  int neighboring[6] = {-1, -1, -1, -1, -1, -1};
  
  int delta = tubeID - fStartTube[sectorID][layerID];
  delta += fShift[sectorID][layerID];
  
  // layer   up: i - 1, i, i +1
  // same layer: i - 1, *, i + 1
  // layer down: i - 1, i, *
  
  int surround[7] = {-1, -1, -1, -1, -1, -1, -1};
  
  if(layerID != fNLayers - 1) {
    surround[0] = fStartTube[sectorID][layerID + 1] + delta - fShift[sectorID][layerID + 1] - 1;
    surround[1] = fStartTube[sectorID][layerID + 1] + delta - fShift[sectorID][layerID + 1];
    surround[2] = fStartTube[sectorID][layerID + 1] + delta - fShift[sectorID][layerID + 1] + 1;
  }
  surround[3] = tubeID - 1;
  surround[4] = tubeID + 1;
  if(layerID != 0) {
    surround[5] = fStartTube[sectorID][layerID - 1] + delta - fShift[sectorID][layerID - 1] - 1;
    surround[6] = fStartTube[sectorID][layerID - 1] + delta - fShift[sectorID][layerID - 1];
  }
  //         \/ 2                /|\ 3
  //  inside -- 2  hexagon_limit /|\ 3
  //         /\ 2                 |  1
  bool hexagon_limit = false;
  if(tubeID == fStartTube[sectorID][layerID] && fShift[sectorID][layerID] == 0) hexagon_limit = true;

  // same layer ----------------------------------------------
  // before
  // if it is not the starting tube of sector 0 or 3 AND
  // if it is not the starting tube of a fillup layer
  // ==> take the previous tube in the same layer
  if(!(tubeID == fStartTube[sectorID][layerID] && sectorID == 0) &&
     !(tubeID == fStartTube[sectorID][layerID] && sectorID == 3) &&
     !(tubeID == fStartTube[sectorID][layerID] && fillup == true)) neighboring[0] = surround[3];
  // after
  // if it is not the ending tube of sector 2 or 5 AND
  // if it is not the ending tube of a fillup layer
  // ==> take the subsequent tube in the same layer
  if(!(tubeID == fEndTube[sectorID][layerID] && sectorID == 2) &&
     !(tubeID == fEndTube[sectorID][layerID] && sectorID == fNSectors - 1) &&
     !(tubeID == fEndTube[sectorID][layerID] && fillup == true)) {
    if(hexagon_limit == true) neighboring[4] = surround[4];
    else neighboring[3] = surround[4];
  }
   
  // layer above ---------------------------------------------
  if(layerID != fNLayers_inner_parallel - 1 && layerID != fNLayers - 1) {
    // @ sector limit
    // if we are at the hexagon limit ==> we take 3 upper tubes
    if(hexagon_limit == true) { // 3 
      if(layerID >= fNLayers_inner_parallel + fNLayers_outer_parallel - 1) { // fillup
	if((surround[0] >= fStartTube[sectorID][layerID + 1]) && (surround[0] <= fEndTube[sectorID][layerID + 1])) neighboring[1] = surround[0];
	if((surround[1] >= fStartTube[sectorID][layerID + 1]) && (surround[1] <= fEndTube[sectorID][layerID + 1])) neighboring[2] = surround[1];
	if((surround[2] >= fStartTube[sectorID][layerID + 1]) && (surround[2] <= fEndTube[sectorID][layerID + 1])) neighboring[3] = surround[2];
      }
      else {
	if(!(tubeID == fStartTube[sectorID][layerID] && sectorID == 0) &&
	   !(tubeID == fStartTube[sectorID][layerID] && sectorID == 3)) neighboring[1] = surround[0];
	neighboring[2] = surround[1];
	if(!(tubeID == fEndTube[sectorID][layerID] && sectorID == 2) &&
	   !(tubeID == fEndTube[sectorID][layerID] && sectorID == fNSectors - 1)) neighboring[3] = surround[2];
      }
    }
    else {
      if(layerID >= fNLayers_inner_parallel + fNLayers_outer_parallel - 1) { // fillup
	if((surround[1] >= fStartTube[sectorID][layerID + 1]) && (surround[1] <= fEndTube[sectorID][layerID + 1])) neighboring[1] = surround[1];
	if((surround[2] >= fStartTube[sectorID][layerID + 1]) && (surround[2] <= fEndTube[sectorID][layerID + 1])) neighboring[2] = surround[2];
      }
      else { 
	cout << tubeID << " " << fEndTube[sectorID][layerID] << " " << sectorID << " " << fNSectors - 1 << endl;
	neighboring[1] = surround[1];
	neighboring[2] = surround[2];
      }
    }
  }
   
  // layer below ---------------------------------------------
  if(layerID != fNLayers_inner_parallel && layerID != 0) {
    // @ sector limit
    // if we are at the hexagon limit ==> we take 1 lower tube
    if(hexagon_limit == true) { // 1
      neighboring[5] = surround[6];
    }
    // inside sector
    // if we are inside the sector, not on the limit 
    // ==> we take 2 lower tubes  (and we check
    // that we are not exiting the sector in case
    // we are in sector 2 or 5 or it is a fillup tube)
    // CHECK the check ;-)
    else {
      neighboring[4] = surround[5];
      if(layerID >= fNLayers_inner_parallel + fNLayers_outer_parallel + 1) { // fillup
	 neighboring[5] = surround[6];
       }
      else if(!(tubeID == fEndTube[sectorID][layerID] && sectorID == 2) &&
	      !(tubeID == fEndTube[sectorID][layerID] && sectorID == fNSectors - 1))  neighboring[5] = surround[6];
    }
  }
  int counter = 0, reduceneighboring[6];
  for(int in = 0; in < 6; in++) {
    if(neighboring[in] != -1) {
      reduceneighboring[counter] = neighboring[in];
      counter++;
    }
  }
  TArrayI neighboringlist(6, reduceneighboring);
  neighboringlist.Set(counter);
  return neighboringlist;
}









ClassImp(PndSttMapCreator)