//   Used MvdUtil as a template
//   Hubert van Hecke   July 2001
//   

#include "MvdGeoRd.hh"
#include "fstream.h"
 
//-----------------------------------------------------------
//  Author     : Hubert van Hecke
//-----------------------------------------------------------
//   Read the mvd geometry from a data base or file  
//   Based on the fortran version
//   Input: data base file
//   load it into a geometry data structure 
//-----------------------------------------------------------
const int MAX = 132;                     // max line length


int mvdread(int date){
  int istat, jdate;
  char line[MAX], line2[MAX];
  char aconfig[650];
  char all_names[350];                                                // list the volume
  float p1,p2,p3,p4,p5,p6,p7,p8,p9,p10;

  if (date > 20010101){
    cout <<"\n MvdGeoRd: MVD year-2 configuration for date "<< date << endl;
    strcpy(aconfig, 
//                                 translate aconfig to imcm(1->12,IB->OT,E->W)
//           <-----SOUTH---->    <-----NORTH---->               
//    pads    1  2  3  4  5  6    7  8  9 10 11 12    pads      
//    ------+--------------------------------------+-------------------------     
      "  0  | 0  0  0  1  1  1    1  1  1  0  0  0 |  1  \n"//     IT
      "  0  | 0  0  0  1  1  1    1  1  1  0  0  0 |  1  \n"//     IM
      "  0  | 0  1  1  1  1  1    1  1  1  1  1  0 |  1  \n"//     IB
      "  0  | 0  1  1  1  1  1    1  1  1  1  1  0 |  1  \n"//     OB   EAST
      "  0  | 0  0  0  0  0  0    0  0  0  0  0  0 |  1  \n"//     OM
      "  0  | 0  0  0  0  0  0    0  0  0  0  0  0 |  1  \n"//     OT
//----------+--------------------------------------+-------------------------
      "  0  | 0  0  0  0  1  1    1  1  0  0  0  0 |  1  \n"//     IT
      "  0  | 0  0  0  1  1  1    1  1  1  0  0  0 |  1  \n"//     IM
      "  0  | 0  1  1  1  1  1    1  1  1  1  1  0 |  1  \n"//     IB   WEST
      "  0  | 0  1  1  1  1  1    1  1  1  1  1  0 |  1  \n"//     OB
      "  0  | 0  0  0  0  0  0    0  0  0  0  0  0 |  1  \n"//     OM
      "  0  | 0  0  0  0  0  0    0  0  0  0  0  0 |  1  \n");//   OT
//----------+--------------------------------------+-------------------------
//     123456789\123456789\123456789\123456789\123456789\
  
                                                                      // List the volume 
  strcpy(all_names,                                                   // names we need to
         "HALL  1" "VERT  1"                                          // make this config.
         "VCG0  1" "VCG0  2" "VCG0  3" "VCG0  4" "VCG0  5" "VCG0  6"  // 24 cages
         "VCG0  7" "VCG0  8" "VCG0  9" "VCG0 10" "VCG0 11" "VCG0 12"
         "VCG0 13" "VCG0 14" "VCG0 15" "VCG0 16" "VCG0 17" "VCG0 18"
         "VCG0 19" "VCG0 20" "VCG0 21" "VCG0 22" "VCG0 23" "VCG0 24"  // And the silicon:
         "VSI4  1" "VSI4  2" "VSI4  3" "VAI4  1" "VSO4  1" "VAO4  1"  // '4'-cage
         "VSI3  1" "VSI3  2" "VAI3  1" "VSO3  1" "VAO3  1"            // '3'-cage
         "VSI2  1" "VAI2  1" "VSO2  1" "VAO2  1"                      // '2'-cage
	 "VPMB  1" "VPMB  2" "VPAD  1");                              // pads
  
  }
  else if (date > 20000101){
    cout <<"\n MvdGeoRd: MVD year-1 configuration for date "<< date << endl;
    strcpy(aconfig, 
//                                 translate aconfig to imcm(1->12,IB->OT,E->W)
//           <-----SOUTH---->    <-----NORTH---->               
//    pads    1  2  3  4  5  6    7  8  9 10 11 12    pads      
//    ------+--------------------------------------+-------------------------     
      "  0  | 0  0  0  0  0  0    1  1  1  0  0  0 |  1  \n"//     IT
      "  0  | 0  0  0  0  0  0    1  1  1  0  0  0 |  1  \n"//     IM
      "  0  | 0  0  0  0  0  0    1  1  1  1  1  0 |  1  \n"//     IB
      "  0  | 0  0  0  0  0  0    1  1  1  1  1  0 |  1  \n"//     OB   EAST
      "  0  | 0  0  0  0  0  0    0  0  0  0  0  0 |  1  \n"//     OM
      "  0  | 0  0  0  0  0  0    0  0  0  0  0  0 |  1  \n"//     OT
//----------+--------------------------------------+-------------------------
      "  0  | 0  0  0  0  0  0    1  1  0  0  0  0 |  1  \n"//     IT
      "  0  | 0  0  0  0  0  0    1  1  1  0  0  0 |  1  \n"//     IM
      "  0  | 0  0  0  0  0  0    1  1  1  1  1  0 |  1  \n"//     IB   WEST
      "  0  | 0  0  0  0  0  0    1  1  1  1  1  0 |  1  \n"//     OB
      "  0  | 0  0  0  0  0  0    0  0  0  0  0  0 |  1  \n"//     OM
      "  0  | 0  0  0  0  0  0    0  0  0  0  0  0 |  1  \n");//   OT
//----------+--------------------------------------+-------------------------
//     123456789\123456789\123456789\123456789\123456789\

                                                                      // list the volume
  strcpy(all_names,                                                   // names we need to
         "HALL  1" "VERT  1"                                          // make this config.
         "VCG0  1" "VCG0  2" "VCG0  3" "VCG0  4" "VCG0  5" "VCG0  6"  // 24 cages
         "VCG0  7" "VCG0  8" "VCG0  9" "VCG0 10" "VCG0 11" "VCG0 12"
         "VCG0 13" "VCG0 14" "VCG0 15" "VCG0 16" "VCG0 17" "VCG0 18"
         "VCG0 19" "VCG0 20" "VCG0 21" "VCG0 22" "VCG0 23" "VCG0 24"  // And the silicon:
         "VSI4  1" "VSI4  2" "VSI4  3" "VAI4  1" "VSO4  1" "VAO4  1"  // '4'-cage
         "VSI3  1" "VSI3  2" "VAI3  1" "VSO3  1" "VAO3  1"            // '3'-cage
         "VSI2  1" "VAI2  1" "VSO2  1" "VAO2  1"                      // '2'-cage
	 "VPMB  1" "VPMB  2" "VPAD  1");                              // pads

  }
  else{
    cout <<"\n MvdGeoRd: MVD year-? configuration for date" << date << endl;
    strcpy(aconfig, 
//                                 translate aconfig to imcm(1->12,IB->OT,E->W)
//           <-----SOUTH---->    <-----NORTH---->               
//    pads    1  2  3  4  5  6    7  8  9 10 11 12    pads      
//    ------+--------------------------------------+-------------------------     
      "  1  | 1  1  1  1  1  1    1  1  1  1  1  1 |  1  \n"//     IT
      "  1  | 1  1  1  1  1  1    1  1  1  1  1  1 |  1  \n"//     IM
      "  1  | 1  1  1  1  1  1    1  1  1  1  1  1 |  1  \n"//     IB
      "  1  | 1  1  1  1  1  1    1  1  1  1  1  1 |  1  \n"//     OB   EAST
      "  1  | 1  1  0  0  0  0    0  0  0  0  1  1 |  1  \n"//     OM
      "  1  | 1  1  0  0  0  0    0  0  0  0  1  1 |  1  \n"//     OT
//----------+--------------------------------------+-------------------------
      "  1  | 1  1  1  1  1  1    1  1  1  1  1  1 |  1  \n"//     IT
      "  1  | 1  1  1  1  1  1    1  1  1  1  1  1 |  1  \n"//     IM
      "  1  | 1  1  1  1  1  1    1  1  1  1  1  1 |  1  \n"//     IB   WEST
      "  1  | 1  1  1  1  1  1    1  1  1  1  1  1 |  1  \n"//     OB
      "  1  | 1  1  0  0  0  0    0  0  0  0  1  1 |  1  \n"//     OM
      "  1  | 1  1  0  0  0  0    0  0  0  0  1  1 |  1  \n");//   OT
//----------+--------------------------------------+-------------------------
//     123456789\123456789\123456789\123456789\123456789\
  
                                                                      // list the volume
  strcpy(all_names,                                                   // names we need to
         "HALL  1" "VERT  1"                                          // make this config.
         "VCG0  1" "VCG0  2" "VCG0  3" "VCG0  4" "VCG0  5" "VCG0  6"  // 24 cages
         "VCG0  7" "VCG0  8" "VCG0  9" "VCG0 10" "VCG0 11" "VCG0 12"
         "VCG0 13" "VCG0 14" "VCG0 15" "VCG0 16" "VCG0 17" "VCG0 18"
         "VCG0 19" "VCG0 20" "VCG0 21" "VCG0 22" "VCG0 23" "VCG0 24"  // And the silicon:
         "VSI4  1" "VSI4  2" "VSI4  3" "VAI4  1" "VSO4  1" "VAO4  1"  // '4'-cage
         "VSI6  1" "VSI6  2" "VSI6  3" "VAI6  1" "VSO6  1" "VSO6  2"  // '6'-cage
         "VSO6  3" "VAO6  1"                                          // 
	 "VPMB  1" "VPMB  2" "VPAD  1" "       ");                    // pads
  
  }            // end of date-based configuration definition

  cout << " aconfig: \n"<< aconfig << endl;

  int imcm[13][7][3];     // 12 in z, 6 in phi, 2 in East-West
  int jconfig = 0;                          // now translate string aconfig
  squeeze (aconfig);                        // remove blanks etc.
  for (int iew=1; iew<=2; iew++){           // copy into 3D array imcm
    for (int igrp=1; igrp<=6; igrp++){      // loop over z, group and east-
      for (int iz=0; iz<=13; iz++){         //                       -west.
        if (iz>=1 && iz<=12){
          imcm[iz][igrp][iew] = int(aconfig[jconfig]) - int('0');
        }    // MCM groups 1-6
//        else if (iz==0)            // south pads
//	else if (iz==13)           // north pads
        jconfig++;
      }      // loop over z 1+12+1
    }        // loop over group 1-6
  }          // loop over east,west

  cout << "imcm  3,2,2= " << imcm[3][2][2] << endl;
  cout << "imcm  4,2,2= " << imcm[4][2][2] << endl;
  cout << "imcm 11,4,1= " << imcm[11][4][1] << endl;
  cout << "imcm 11,5,1= " << imcm[11][5][1] << endl;

  int ivol = index(all_names,"HALL  1")/7 +1;
  cout <<" HALL  1  position: "<<ivol<<endl;
  ivol = index(all_names,"VERT  1")/7 +1;
  cout <<" VERT  1  position: "<<ivol<<endl;
  ivol = index(all_names,"VPMB  2")/7 +1;
  cout <<" VPMB  2  position: "<<ivol<<endl;
  ivol = index(all_names,"VPAD  1")/7 +1;
  cout <<" VPAD  1  position: "<<ivol<<endl;
  ivol = index(all_names,"VERX  1")/7 +1;
  cout <<" VERX  1  position: "<<ivol<<endl;


  ifstream infile("ver_geom.dat");                      // open data base file
  while (infile){                                       // read whole thing
    infile.getline(line, MAX,'\n');                     // read line
    //cout <<"line:"<< line <<endl;                     //
    if (!is_comment(line)){                             // skip comments    
      int istat = parseline(line,1,jdate);              // read the timestamp
      if (jdate <= date){                               // timestamp match?  
        infile.getline(line2, MAX,'\n');                // read second line
        //cout <<" date= "<< jdate << endl;             //
                                                        // see if it is a requested volume
	char name[8] = {'\0','\0','\0','\0','\0','\0','\0','\0'};
	char shape[5];
	int nmed;
        int icopy;
	istat = parseline(line,2, name, shape, nmed, icopy);  //
        char acopy[3];
        sprintf (acopy,"%3d",icopy);
        for (int i=0; i<=2; i++) name[4+i] = acopy[i];        // combine name+copy
        if (index(all_names,name)>=0){                            // name was requested
          //cout << line << "\n";
          char mother[5];
          float xyz[3], x, y, z;
          int irot, iseen, icol;
	  char only[5];
          char comm[2];                                             // get the rest:
          istat = parseline(line,6, mother, x, y, z, irot, only, iseen, icol, comm);

          cout <<  jdate<<" "<<name<<" "<<shape<<" "<<nmed<<" "<<icopy<<" ";
          cout << mother<<" "<< x<<" "<< y <<" "<< z <<" "<<irot<<" "<<only<<" ";
	  cout << iseen<<" "<<icol<<" "<<comm<<endl;

	  if      (strcmp(shape,"BOX")==0){
	    cout << " this is a box \n";
            istat = parseline(line2, 1, p1, p2, p3);
          }
	  else if (strcmp(shape,"TUBE")==0){
            cout<<" this is a tube \n";
            istat = parseline(line2, 1, p1, p2, p3);
          }
	  else if (strcmp(shape,"PGON")==0){
            cout<<" this is a pgon \n";
            istat = parseline(line2, 1, p1, p2, p3);
          }
	  else if (strcmp(shape,"PARA")==0){
            cout<<" this is a para \n";
            istat = parseline(line2, 1, p1, p2, p3);
          }
          cout << p1 <<" "<< p2 <<" "<< p3 <<" "<< p4 <<" "<< p5 <<" ";
          cout << p6 <<" "<< p7 <<" "<< p8 <<" "<< p9 <<" "<< p10 << endl;
	}                           // name was requested
        //else cout <<" no request for this name: "<< name <<endl;
      }                                                 // timestamp match
    }
  }                    // end while infile


  istat = 1;
  return istat;
}                      // end mvdRead
//==========================================================================//
int parseline(char* line, int istart, float& p1, float& p2, float& p3){ 

  int nvar = 0;
  int i = 0;
  int slen = strlen(line);
  while (line[i]==' '  && i<slen) i++;   // skip over leading blanks
  while (nvar<istart-1){                 // skip over the first istart-1
    while (line[i]==' ' && i<slen) i++;  //        items in the input string
    while (line[i]!=' ' && i<slen) i++;  //
    nvar++;                              //
    i++;                                 //
  }                                      // end skip

  char var[20];                          //
  for (int ivar=1; ivar<=3; ivar++){     // loop over 3 vars to be 
    int j=0;                             // extracted
    while (line[i]!=' ' && i<slen){      // copy element to 
      var[j] = line[i];                  // temporary string 'var'
      i++; j++;                          //
    }                                    // end copy string
    var[j] = '\0';                       // terminate string
    while (line[i]==' ' && i<slen) i++;  // skip next blank space
                                         //
    switch (ivar){                       // convert variables
      case 1:                            // first variable is mother vol name
        sscanf(var,"%f",&p1);            // convert to p1
        break;                           // jump out
      case 2:                            // 
        sscanf(var,"%f",&p2);             // convert to p2
        break;                           // jump out
      case 3:                            // 
        sscanf(var,"%f",&p3);             // convert to p3
        break;                           //
    }
  }
}

int parseline(char* line, int istart, char* mother, float& x, float& y, float& z, 
	      int& irot, char* only, int& iseen, int& icolor, char* comm){

  int nvar = 0;
  int i = 0;
  int slen = strlen(line);
  while (nvar<istart-1){                 // skip over the first istart-1
    while (line[i]==' ' && i<slen) i++;  //        items in the input string
    while (line[i]!=' ' && i<slen) i++;  //
    nvar++;                              //
    i++;                                 //
  }                                      // end skip

  char var[20];                          //
  for (int ivar=1; ivar<=9; ivar++){     // loop over 9 vars to be 
    int j=0;                             // extracted
    while (line[i]!=' ' && i<slen){      // copy element to 
      var[j] = line[i];                  // temporary string 'var'
      i++; j++;                          //
    }                                    // end copy string
    var[j] = '\0';                       // terminate string
    while (line[i]==' ' && i<slen) i++;  // skip next blank space
                                         //
    switch (ivar){                       // convert variables
      case 1:                            // first variable is mother vol name
        sscanf(var,"%4c",mother);        // copy to x
        break;                           // jump out
      case 2:                            // 
        sscanf(var,"%f",&x);             // convert to x
        break;                           // jump out
      case 3:                            // 
        sscanf(var,"%f",&y);             // convert to y
        break;                           //
      case 4:                            //
        sscanf(var,"%f",&z);             // convert to z
        break;                           //
      case 5:
        sscanf(var,"%d",&irot);          // convert to irot
        break;
      case 6:
        sscanf(var,"%4c",only);          // copy to only
        break;
      case 7:
        sscanf(var,"%d",&iseen);         // convert to iseen
        break;
      case 8:
        sscanf(var,"%d",&icolor);        // convert to icolor
        break;
      case 9:
        sscanf(var,"%d",comm);           // convert to comm
        break;
    }                                    // end switch on ivar
  }                                      // end loop over 4 variables
  return 1;
}               // end overloaded parseline
//--------------------------------------------------------------------------//

int parseline(char* line, int istart, char* name, char* shape, int& nmed, int& icopy){
  int slen = strlen(line);
  int nvar = 0;
  int i = 0;
  while (nvar<istart-1){                 // skip over the first istart-1
    while (line[i]==' ' && i<slen) i++;  //        items in the input string
    while (line[i]!=' ' && i<slen) i++;  //
    nvar++;                              //
    i++;                                 //
  }                                      // end skip

  char var[20];                          //
  for (int ivar=1; ivar<=4; ivar++){     // loop over 4 vars to be 
    int j=0;                             // extracted
    while (line[i]!=' '  && i<slen){     // copy element to 
      var[j] = line[i];                  // temporary string 'var'
      i++; j++;                          //
    }                                    // end copy string
    var[j] = '\0';                       // terminate string
    while (line[i]==' ' && i<slen) i++;  // skip next blank space
                                         //
    switch (ivar){                       // convert variables
      case 1:                            // first variable is 'name'
        sscanf(var,"%4c",name);          // copy to name
        break;                           // jump out
      case 2:
        sscanf(var,"%s",shape);          // copy to shape
        break;
      case 3:
        sscanf(var,"%d",&nmed);          // convert to nmed
        break;
      case 4:
        sscanf(var,"%d",&icopy);         // convert to icopy
        break;
    }                                    // end switch on ivar
  }                                      // end loop over 4 variables
  return 1;
}
//--------------------------------------------------------------------------//

int parseline(char* line, int istart, int& jdate){
// note the return argument jdate is passed 'by reference', also see the prototype
  //
  int slen = strlen(line);
  char adate[9];
  int i=0;
  int j=0;

  while (line[i]==' '  && i<slen) i++;       // skip over leading blanks
                                    //
  while (line[i] != ' ' && i<slen){           // copy number from line
    adate[j] = line[i];             // into adate
    i++;                            //
    j++;                            //
  }                                 //
  adate[j] = '\0';                  //
  sscanf(adate,"%d",&jdate);        // convert to integer
  if      (jdate == 0                        ) jdate =         99999999;
  else if (jdate >  0      && jdate <= 501230) jdate = jdate + 20000000;
  else if (jdate >= 501231 && jdate <= 991231) jdate = jdate + 19000000;
  return 1;                         //                   
}                                   // end parseline ( ,1, )
//==========================================================================//

void squeeze(char* line){
//--------------------------------------------------------------------------//
// This function removes blanks, newlines and | from the input 
// string 'line' and returns 'line' with null after the last 
// non-blank character. 
// July 2001 HvH
//--------------------------------------------------------------------------//
  int slen = strlen(line);
  char line2[slen];
  int k=0;
  for (int j=0; j<slen; j++){
    if (line[j] != ' ' && line[j] != '|' && line[j] != '\n') {
      line2[k] = line[j];
      k++;
    }                  // nonblank char seen
  }                    // end for over string
                       // now copy the string back:
  for (int j=0; j<k; j++) line[j] = line2[j];    
  line[k] = '\0';      // append null string terminator
}                      // end squeeze
//==========================================================================//

int is_comment(char* line){
  if (line[0]=='/' && line[1]=='/') return 1;
  if (line[0]=='*'                ) return 1;
  if (index(line,"GSROTM") >= 0)    return 1;
  return 0;
}                 // end is_comment
//==========================================================================//

int index(char* line, char* elem){
  int lenline = strlen(line);
  int lenelem = strlen(elem);
  int i=0;
  int j;         // declare outside while loop
  while (i<=lenline-lenelem){
    j=0;
    while (j<=lenelem){
      if (line[i+j] != elem[j]) break;
      j++;
    }
    if (j==lenelem) break;
    i++;
  }               //end while
  if ((i+lenelem-1 == lenline) && (j != lenelem+1)) i = -lenelem;
  return i;
}                // end index
//==========================================================================//