Reference Manual

Go to the documentation of this file.
00001 #ifndef _TrackerMap_h_
00002 #define _TrackerMap_h_
00003 #include <utility>
00004 #include <string>
00005 #include <iostream>
00006 #include <fstream>
00007 #include <sstream>
00008 #include <cmath>
00009 #include <map>
00010 #include "FWCore/ParameterSet/interface/ParameterSet.h"
00011 #include "FWCore/Framework/interface/ESHandle.h"
00012 #include "CondFormats/SiStripObjects/interface/SiStripFedCabling.h"
00013 #include "TColor.h"
00014 
00015 /*
00016 #define  NUMFEDCH_INCOLUMN 12
00017 #define  NUMFEDCH_INROW 8
00018 #define  NUMFED_INCOLUMN 6
00019 #define  NUMFED_INROW 4
00020 #define  NUMFEDCRATE_INCOLUMN 3
00021 #define  XFEDCSIZE  340
00022 #define  YFEDCSIZE  400
00023 */
00024 
00025 /*
00026 #define  NUMFEDCH_INCOLUMN 12
00027 #define  NUMFEDCH_INROW 8
00028 #define  NUMFED_INCOLUMN 1
00029 #define  NUMFED_INROW 21
00030 //#define  NUMFEDCRATE_INCOLUMN 11
00031 //#define  NUMFEDCRATE_INROW 3
00032 #define  NUMFEDCRATE_INCOLUMN 16
00033 #define  NUMFEDCRATE_INROW 2
00034 //#define  XFEDCSIZE  160  // 14 boxes
00035 //#define  YFEDCSIZE  2100 // 9*21 boxes
00036 #define  XFEDCSIZE  140  // 14 boxes
00037 #define  YFEDCSIZE  1890 // 9*21 boxes
00038 */
00039 
00040 #define  NUMPSUCH_INROW 18
00041 #define  NUMPSUCRATE_INCOLUMN 5
00042 #define  NUMPSURACK_INCOLUMN 6
00043 #define  NUMPSURACK_INROW 5
00044 #define  XPSURSIZE  150 // (5)*1.5 boxes
00045 #define  YPSURSIZE  360 // 18 boxes 
00046 #define  XPSUOFFSET 50
00047 #define  YPSUOFFSET 100
00048 
00049 #define  NUMFEDCH_INCOLUMN 12
00050 #define  NUMFEDCH_INROW 8
00051 #define  NUMFED_INCOLUMN 21
00052 #define  NUMFED_INROW 1
00053 //#define  NUMFEDCRATE_INCOLUMN 11
00054 //#define  NUMFEDCRATE_INROW 3
00055 #define  NUMFEDCRATE_INCOLUMN 1
00056 #define  NUMFEDCRATE_INROW 31
00057 //#define  XFEDCSIZE  160  // 14 boxes
00058 //#define  YFEDCSIZE  2100 // 9*21 boxes
00059 #define  XFEDCSIZE  2940  // 14*21 boxes
00060 #define  YFEDCSIZE  90 // 9 boxes
00061 #define  XFEDOFFSET 150
00062 #define  YFEDOFFSET 100
00063 
00064 class TmModule;
00065 class TmApvPair;
00066 class EventSetup;
00067 class TmCcu;
00068 class TmPsu;
00069 
00070 class TrackerMap {
00071  public:
00072   //TrackerMap(){TrackerMap(" ");};   //!< default constructor
00073   TrackerMap(std::string s=" ",int xsize1=340,int ysize1=200);
00074   TrackerMap(const edm::ParameterSet & iConfig);
00075   TrackerMap(const edm::ParameterSet & iConfig,const SiStripFedCabling* tkFed);
00076   ~TrackerMap();  
00077   
00078   void build();
00079   void init();
00080   void drawModule(TmModule * mod, int key, int layer, bool total, std::ofstream * file);
00081   void print(bool print_total=true,float minval=0., float maxval=0.,std::string s="svgmap");
00082   void printall(bool print_total=true,float minval=0., float maxval=0.,std::string s="svgmap",int width=6000, int height=3200);
00083   void printonline();
00084   void printlayers(bool print_total=true,float minval=0., float maxval=0.,std::string s="layer");
00085   void save(bool print_total=true,float minval=0., float maxval=0.,std::string s="svgmap.svg",int width=1500, int height=800);
00086   void save_as_fedtrackermap(bool print_total=true,float minval=0., float maxval=0.,std::string s="fed_svgmap.svg",
00087                              int width=YFEDOFFSET+(YFEDCSIZE+YFEDOFFSET)*NUMFEDCRATE_INROW+300,
00088                              int height=XFEDOFFSET+(XFEDCSIZE+XFEDOFFSET)*NUMFEDCRATE_INCOLUMN+300);
00089   void save_as_fectrackermap(bool print_total=true,float minval=0., float maxval=0.,std::string s="fec_svgmap.svg",int width=1500, int height=800);
00090   void save_as_psutrackermap(bool print_total=true,float minval=0., float maxval=0.,std::string s="psu_svgmap.svg",
00091                              int width=YPSUOFFSET+(YPSURSIZE+YPSUOFFSET)*NUMPSURACK_INROW+300, 
00092                              int height=XPSUOFFSET+(XPSURSIZE+XPSUOFFSET)*NUMPSURACK_INCOLUMN+300);
00093   void save_as_HVtrackermap(bool print_total=true,float minval=0., float maxval=0.,std::string s="psu_svgmap.svg",int width=1500, int height=800);
00094   void drawApvPair( int crate, int numfed_incrate, bool total, TmApvPair* apvPair,std::ofstream * file,bool useApvPairValue);
00095   void drawCcu( int crate, int numfed_incrate, bool total, TmCcu* ccu,std::ofstream * file,bool useCcuValue);
00096   void drawPsu(int rack,int numcrate_inrack, bool print_total, TmPsu* psu,ofstream * svgfile,bool usePsuValue);
00097   void drawHV2(int rack,int numcrate_inrack, bool print_total, TmPsu* psu,ofstream * svgfile,bool usePsuValue);
00098   void drawHV3(int rack,int numcrate_inrack, bool print_total, TmPsu* psu,ofstream * svgfile,bool usePsuValue);
00099   void fill_current_val(int idmod, float current_val );
00100   void fill(int layer , int ring, int nmod, float x );
00101   void fill(int idmod, float qty );
00102   void fillc(int idmod, int RGBcode) {fillc(idmod,(RGBcode>>16) & 0xFF , (RGBcode>>8) & 0xFF, RGBcode & 0xFF);}
00103   void fillc(int idmod, int red, int green, int blue);
00104   void fillc(int layer,int ring, int nmod, int red, int green, int blue);
00105   void fillc_all_blank();
00106   void fill_all_blank();
00107   void fill_current_val_fed_channel(int fedId,int fedCh, float current_val );
00108   void fill_fed_channel(int fedId,int fedCh, float qty );
00109   void fill_fed_channel(int modId, float qty );
00110   void fillc_fed_channel(int fedId,int fedCh, int red, int green, int blue);
00111   void fillc_fec_channel(int crate,int slot, int ring, int addr, int red, int green, int blue  );
00112   void fill_fec_channel(int crate,int slot, int ring, int addr, float qty  );
00113   void fill_lv_channel(int rack,int crate, int board, float qty  );
00114   void fillc_lv_channel(int rack,int crate, int board, int red, int green, int blue);
00115   void fill_hv_channel2(int rack,int crate, int board, float qty  );
00116   void fillc_hv_channel2(int rack,int crate, int board, int red, int green, int blue);
00117   void fill_hv_channel3(int rack,int crate, int board, float qty  );
00118   void fillc_hv_channel3(int rack,int crate, int board, int red, int green, int blue);
00119   int module(int fedId,int fedCh);
00120   void setText(int idmod , std::string s );
00121   void setText(int layer, int ring, int nmod , std::string s );
00122   void setPalette(int numpalette){palette=numpalette;} 
00123   void drawPalette(std::ofstream * file, int xoffset=3660, int yoffset=1540); 
00124   void showPalette(bool printflag1){printflag=printflag1;}; 
00125   void setTitle(std::string s){title=s;};
00126   void setRange(float min,float max);
00127   std::pair<float,float>getAutomaticRange();
00128   void addPixel(bool addPixelfl){addPixelFlag=addPixelfl;};
00129   void reset();
00130   void load(std::string s="tmap.svg"); 
00131   int getxsize(){return xsize;};
00132   int getysize(){return ysize;};
00133   int getcolor(float value, int palette);
00134   std::ifstream * findfile(std::string filename);
00135   int getNumMod(){return number_modules;};
00136   std::vector<TColor*> vc; 
00137   typedef std::map<const int  , TmModule *> SmoduleMap;
00138   SmoduleMap smoduleMap;
00139   typedef std::map<const int  , TmModule *> ImoduleMap;
00140   ImoduleMap imoduleMap;
00141   typedef std::map<const int  , TmApvPair*> SvgApvPair;
00142   SvgApvPair apvMap;
00143   typedef std::multimap<const int  , TmApvPair*> ModApvPair;
00144    ModApvPair apvModuleMap;
00145   typedef std::map<const int  , int>  SvgFed;
00146   SvgFed fedMap;
00147   SvgFed slotMap;
00148   typedef std::map<const int  , TmCcu*> MapCcu;
00149   MapCcu  ccuMap;
00150   typedef std::multimap<TmCcu*  , TmModule*> FecModule;
00151   FecModule fecModuleMap;
00152   typedef std::map<const int  , TmPsu*> MapPsu;
00153   MapPsu  psuMap;
00154   typedef std::multimap<TmPsu*  , TmModule*> PsuModule;
00155   PsuModule psuModuleMap;
00156   int palette;
00157   bool printflag;
00158   bool saveWebInterface;
00159   bool saveGeoTrackerMap;
00160   bool enableFedProcessing;
00161   bool enableFecProcessing;
00162   bool enableLVProcessing;
00163   bool enableHVProcessing;
00164   bool tkMapLog;
00165   int ndet; //number of detectors 
00166   int npart; //number of detectors parts 
00167   std::string title;
00168    std::string jsfilename,infilename;
00169   std::string jsPath;
00170    bool psetAvailable;
00171   double phival(double x, double y){
00172     double phi;
00173     double phi1=atan(y/x);
00174     phi = phi1;
00175     if(y<0. && x>0) phi = phi1+2.*M_PI;
00176     if(x<0.)phi=phi1+M_PI;
00177     if(fabs(y)<0.000001 && x>0)phi=0;
00178     if(fabs(y)<0.000001&&x<0)phi=M_PI;
00179     if(fabs(x)<0.000001&&y>0)phi=M_PI/2.;
00180     if(fabs(x)<0.000001&&y<0)phi=3.*M_PI/2.;
00181       
00182     return phi;
00183   }
00184   
00185   int find_layer(int ix, int iy)
00186     {
00187       int add;
00188       int layer=0;
00189       if(iy <= xsize){//endcap+z
00190         add = 15;
00191         layer = ix/ysize;
00192         layer = layer+add+1;
00193       }
00194       if(iy > xsize && iy< 3*xsize){//barrel
00195         add=30;
00196         if(ix < 2*ysize){
00197           layer=1;
00198         }else {
00199           layer = ix/(2*ysize);
00200           if(iy < 2*xsize)layer=layer*2+1; else layer=layer*2;
00201         }
00202         layer = layer+add;
00203       }
00204       if(iy >= 3*xsize){        //endcap-z
00205         layer = ix/ysize;
00206         layer = 15-layer;
00207       }
00208       return layer;  
00209     }
00210 
00211   int getlayerCount(int subdet, int partdet){
00212     int ncomponent=0;
00213     if(subdet == 1){ //1=pixel
00214       if(partdet == 1 || partdet == 3){ //1-3=encap
00215         ncomponent = 3;
00216       }
00217       else { ncomponent = 3; } //barrel
00218     }
00219     if(subdet== 2){ //2=inner silicon
00220       if(partdet == 1 || partdet == 3){ //1-3=encap
00221         ncomponent = 3;
00222       }
00223       else { ncomponent = 4; } //barrel
00224     }
00225     if(subdet== 3){ //3=outer silicon
00226       if(partdet == 1 || partdet == 3){ //1-3=encap
00227         ncomponent = 9;
00228       }
00229       else { ncomponent = 6; } //barrel
00230     }
00231     return(ncomponent);
00232   }   
00233   double  xdpixel(double x){
00234     double res;
00235     if(saveAsSingleLayer)res= ((x-xmin)/(xmax-xmin)*xsize);
00236     else res= ((x-xmin)/(xmax-xmin)*xsize)+ix;
00237     return res;
00238   }
00239   double  ydpixel(double y){
00240     double res=0;
00241     double y1;
00242     y1 = (y-ymin)/(ymax-ymin);
00243     if(nlay>30)
00244        {
00245         if(nlay <34) res= 2*ysize - (y1*2*ysize);
00246         if(nlay==34) res= 2.4*ysize - (y1*2.4*ysize);
00247         if(nlay>34) res= 2.5*ysize - (y1*2.5*ysize);  
00248         }
00249     else res= xsize - (y1*xsize);
00250     if(!saveAsSingleLayer) res=res+iy;
00251     return res;
00252   }
00253   double  xdpixelc(double x){
00254     double res;
00255     if(saveAsSingleLayer)res= ((x-xmin)/(xmax-xmin)*XFEDCSIZE);
00256     else res= ((x-xmin)/(xmax-xmin)*XFEDCSIZE)+ix;
00257     return res;
00258   }
00259   double  ydpixelc(double y){
00260     double res;
00261     double y1;
00262     y1 = (y-ymin)/(ymax-ymin);
00263      if(saveAsSingleLayer)res= YFEDCSIZE - (y1*YFEDCSIZE);
00264      else res= YFEDCSIZE - (y1*YFEDCSIZE)+iy;
00265     return res;
00266   }
00267   double  xdpixelfec(double x){
00268     double res;
00269     if(saveAsSingleLayer)res= ((x-xmin)/(xmax-xmin)*xsize);
00270     else res= ((x-xmin)/(xmax-xmin)*xsize)+ix;
00271     return res;
00272   }
00273   double  ydpixelfec(double y){
00274     double res;
00275     double y1;
00276     y1 = (y-ymin)/(ymax-ymin);
00277      if(saveAsSingleLayer)res= 2*ysize - (y1*2*ysize);
00278      else res= 2*ysize - (y1*2*ysize)+iy;
00279     return res;
00280   }
00281   double  xdpixelpsu(double x){
00282     double res;
00283     if(saveAsSingleLayer)res= ((x-xmin)/(xmax-xmin)*XPSURSIZE);
00284     else res= ((x-xmin)/(xmax-xmin)*XPSURSIZE)+ix;
00285     return res;
00286   }
00287    double  ydpixelpsu(double y){
00288     double res;
00289     double y1;
00290     y1 = (y-ymin)/(ymax-ymin);
00291      if(saveAsSingleLayer)res=YPSURSIZE - (y1*YPSURSIZE);
00292      else res= YPSURSIZE - (y1*YPSURSIZE)+iy;
00293     return res;
00294   }
00295 
00296    void defcwindow(int num_crate){
00297      //    ncrate = num_crate;
00298      int xoffset=XFEDOFFSET;
00299     int yoffset=YFEDOFFSET;
00300     xmin=0.;xmax=(NUMFEDCH_INCOLUMN+2)*NUMFED_INCOLUMN;  ymin = 0.; ymax=(NUMFEDCH_INROW+1)*NUMFED_INROW;
00301 
00302     ix = xoffset+((NUMFEDCRATE_INCOLUMN-1)-((num_crate-1)%NUMFEDCRATE_INCOLUMN))*(XFEDCSIZE+XFEDOFFSET);
00303     iy = yoffset+((num_crate-1)/NUMFEDCRATE_INCOLUMN)*(YFEDCSIZE+YFEDOFFSET);
00304   } 
00305    void deffecwindow(int num_crate){
00306      //    ncrate = num_crate;
00307     int xoffset=xsize/3;
00308     int yoffset=2*ysize;
00309     xmin=-1.;xmax=37.;  ymin = -10.; ymax=40.;
00310     if(num_crate==1||num_crate==3)ix = xoffset+xsize*2;
00311     if(num_crate==2||num_crate==4)ix = xoffset;
00312     iy = yoffset+((num_crate-1)/2)*ysize*4;
00313   }
00314    void defpsuwindow(int num_rack){
00315      //    nrack = num_rack;
00316     int xoffset=XPSUOFFSET;
00317     int yoffset=YPSUOFFSET;
00318     xmin=0; xmax=(NUMPSUCRATE_INCOLUMN)*1.5;
00319     ymin=0; ymax=NUMPSUCH_INROW;
00320 
00321     ix = xoffset+((NUMPSURACK_INCOLUMN-1)-((num_rack-1)%NUMPSURACK_INCOLUMN))*(XPSURSIZE+XPSUOFFSET);
00322     iy = yoffset+((num_rack-1)/NUMPSURACK_INCOLUMN)*(YPSURSIZE+YPSUOFFSET);
00323     }
00324 
00325 
00326 void defwindow(int num_lay){
00327   // nlay = num_lay;
00328   if(posrel){ // separated modules
00329     xmin=-2.;ymin=-2.;xmax=2.;ymax=2.;
00330     if(num_lay >12 && num_lay < 19){
00331       xmin=-.40;xmax=.40;ymin=-.40;ymax=.40;
00332     }
00333     if(num_lay>30){
00334       xmin=-0.1;xmax=3.;ymin=-0.1;ymax=8.5;
00335       if(num_lay<34){xmin=-0.3;xmax=1.0;}
00336       if(num_lay>33&&num_lay<38){xmax=2.0;}
00337       if(num_lay>37){ymax=8.;}//inner
00338     }
00339   }else{ //overlayed modules
00340     xmin=-1.3;ymin=-1.3;xmax=1.3;ymax=1.3;
00341     if(num_lay >12 && num_lay < 19){
00342       xmin=-.20;xmax=.20;ymin=-.20;ymax=.20;
00343     }
00344     if(num_lay>30){
00345       xmin=-1.5;xmax=1.5;ymin=-1.;ymax=28.;
00346       if(num_lay<34){xmin=-0.5;xmax=0.5;}
00347       if(num_lay>33&&num_lay<38){xmin=-1.;xmax=1.;}
00348     }
00349     
00350   }
00351   if(num_lay<16){
00352       ix=0;
00353       if(num_lay==15||num_lay==14)iy=(15-num_lay)*2*ysize; else 
00354           {if(num_lay>9&&num_lay<13)iy=4*ysize-(int)(ysize/2.)+(12-num_lay)*(int)(ysize/1.50);else iy=6*ysize+(9-num_lay)*(int)(ysize*1.3);}}
00355   if(num_lay>15&&num_lay<31){
00356     ix=3*xsize;
00357      if(num_lay==16||num_lay==17)iy=(num_lay-16)*2*ysize; else 
00358           {if(num_lay>18&&num_lay<22)iy=4*ysize-(int)(ysize/2.)+(num_lay-19)*(int)(ysize/1.50);else iy=6*ysize+(num_lay-22)*(int)(ysize*1.3);}}
00359   if(num_lay>30){
00360     if(num_lay==31){ix=(int)(1.5*xsize);iy=0;}
00361     if(num_lay==32){int il=(num_lay-30)/2;ix=xsize;iy=il*2*ysize;}
00362     if(num_lay==33){int il=(num_lay-30)/2;ix=2*xsize;iy=il*2*ysize;}
00363     if(num_lay==34){int il=(num_lay-30)/2;ix=xsize;iy=il*(int)(2.57*ysize);}
00364     if(num_lay>34 && num_lay%2==0){int il=(num_lay-30)/2;ix=xsize;iy=il*(int)(2.5*ysize);}
00365     if(num_lay>34 && num_lay%2!=0){int il=(num_lay-30)/2;ix=2*xsize;iy=il*(int)(2.5*ysize);}
00366   }
00367 }
00368   
00369   int getringCount(int subdet, int partdet, int layer){
00370     int ncomponent=0;
00371     if(subdet== 1){ //1=pixel
00372       if(partdet== 1 || partdet== 3){ //end-cap
00373         ncomponent = 7;
00374       }
00375       else{ncomponent = 8;} //barrel
00376     }   
00377     if(subdet== 2){ //inner-silicon
00378       if(partdet== 1 || partdet== 3){ //end-cap
00379         ncomponent = 3;
00380       }
00381       else{ncomponent = 12;} //barrel
00382     }
00383     if(subdet== 3){ //outer-silicon
00384       if(partdet== 1){ //end-cap-z
00385         if (layer== 1) ncomponent = 4;
00386         if (layer== 2 || layer== 3) ncomponent = 5;
00387         if (layer== 4 || layer== 5 || layer== 6) ncomponent = 6;
00388         if (layer== 7 || layer== 8 || layer== 9) ncomponent = 7;
00389       }
00390       if(partdet== 3){ //endcap+z
00391         if (layer== 9) ncomponent = 4;
00392         if (layer== 8 || layer== 7) ncomponent = 5;
00393         if (layer== 6 || layer== 5 || layer== 4) ncomponent = 6;
00394         if (layer== 3 || layer== 2 || layer== 1) ncomponent = 7;
00395       }
00396       if(partdet== 2){ //barrel
00397         ncomponent = 12;
00398       }
00399     }
00400     return(ncomponent);
00401   }
00402   int getmoduleCount(int subdet, int partdet, int layer, int ring){
00403     int ncomponent=0;
00404     int spicchif[] ={24,24,40,56,40,56,80};
00405     int spicchib[] ={20,32,44,30,38,46,56,42,48,54,60,66,74};
00406     int numero_layer = 0;
00407     
00408     if(partdet == 2){ //barrel
00409       numero_layer = layer-1;
00410       if(subdet== 2){ //inner
00411         numero_layer = numero_layer+3;
00412       }
00413       if(subdet == 3){ //outer
00414         numero_layer = numero_layer+7;
00415       }
00416       ncomponent = spicchib[numero_layer];
00417     }
00418     if(partdet!= 2){ //endcap
00419       if(subdet== 1)ncomponent=24;//pixel
00420       else
00421         ncomponent = spicchif[ring-1];
00422     }
00423     return(ncomponent);
00424   }
00425   static int layerno(int subdet,int leftright,int layer){
00426     if(subdet==6&&leftright==1)return(10-layer);
00427     if(subdet==6&&leftright==2)return(layer+21);
00428     if(subdet==4&&leftright==1)return(4-layer+9);
00429     if(subdet==4&&leftright==2)return(layer+18);
00430     if(subdet==2&&leftright==1)return(4-layer+12);
00431     if(subdet==2&&leftright==2)return(layer+15);
00432     if(subdet==1)return(layer+30);
00433     if(subdet==3)return(layer+33);
00434     if(subdet==5)return(layer+37);
00435   }
00436   
00437   static bool isRingStereo(int key){
00438     int layer=key/100000;
00439     int ring = key - layer*100000;
00440     ring = ring/1000;
00441     if(layer==34 || layer==35 || layer==38 || layer==39) return true;
00442     if(layer<13 || (layer>18&&layer<31))
00443       if(ring==1 || ring==2 || ring==5)return true;
00444     return false;
00445   }
00446   int nlayer(int det,int part,int lay){
00447     if(det==3 && part==1) return lay;
00448     if(det==2 && part==1) return lay+9;
00449     if(det==1 && part==1) return lay+12;
00450     if(det==1 && part==3) return lay+15;
00451     if(det==2 && part==3) return lay+18;
00452     if(det==3 && part==3) return lay+21;
00453     if(det==1 && part==2) return lay+30;
00454     if(det==2 && part==2) return lay+33;
00455     if(det==3 && part==2) return lay+37;
00456     return -1; 
00457   }
00458   
00459   std::string layername(int layer){
00460     std::string s= " ";
00461     std::ostringstream ons;
00462     
00463     if(layer < 10) ons << "TEC -z Layer " << layer;
00464     if(layer < 13 && layer > 9) ons << "TID -z Layer " << layer-9;
00465     if(layer < 16 && layer > 12) ons << "FPIX -z Layer " << layer-12;
00466     if(layer < 19 && layer > 15) ons << "FPIX +z Layer " << layer-15;
00467     if(layer < 22 && layer > 18) ons << "TID +z Layer " << layer-18;
00468     if(layer < 31 && layer > 21) ons << "TEC +z Layer " << layer-21;
00469     if(layer < 34 && layer > 30) ons << "TPB Layer " << layer-30;
00470     if(layer < 38 && layer > 33) ons << "TIB Layer " << layer-33;
00471     if(layer > 37) ons << "TOB Layer " << layer-37;
00472     s = ons.str(); 
00473     return s;  
00474   }
00475   int ntotRing[43];
00476   int firstRing[43];
00477   
00478  protected:
00479   int nlay;
00480   //  int ncrate;
00481   //  int nrack;
00482   int ncrates;
00483   int firstcrate;
00484   int nfeccrates;
00485   int npsuracks;
00486   double xmin,xmax,ymin,ymax;
00487   int xsize,ysize,ix,iy;
00488   bool posrel;
00489   bool firstcall;
00490   std::ofstream * svgfile;
00491   std::ofstream * savefile;
00492   std::ifstream * jsfile;
00493   std::ifstream * inputfile;
00494   std::ifstream * ccufile;
00495   float gminvalue,gmaxvalue;
00496   float minvalue,maxvalue;
00497   int number_modules;
00498   bool temporary_file; 
00499   
00500  private:
00501   
00502   float oldz;
00503   bool saveAsSingleLayer;
00504   bool addPixelFlag;
00505 };
00506 #endif
00507
/data/refman/pasoursint/CMSSW_6_1_2_SLHC2_patch1/src/CommonTools/TrackerMap/interface/TrackerMap.h
