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