TrackerMap.h

Go to the documentation of this file.

#ifndef _TrackerMap_h_
#define _TrackerMap_h_
#include <utility>
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <cmath>
#include <map>
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "CondFormats/SiStripObjects/interface/SiStripFedCabling.h"
#include "TColor.h"
#include <cassert>

/*
#define  NUMFEDCH_INCOLUMN 12
#define  NUMFEDCH_INROW 8
#define  NUMFED_INCOLUMN 6
#define  NUMFED_INROW 4
#define  NUMFEDCRATE_INCOLUMN 3
#define  XFEDCSIZE  340
#define  YFEDCSIZE  400
*/

/*
#define  NUMFEDCH_INCOLUMN 12
#define  NUMFEDCH_INROW 8
#define  NUMFED_INCOLUMN 1
#define  NUMFED_INROW 21
//#define  NUMFEDCRATE_INCOLUMN 11
//#define  NUMFEDCRATE_INROW 3
#define  NUMFEDCRATE_INCOLUMN 16
#define  NUMFEDCRATE_INROW 2
//#define  XFEDCSIZE  160  // 14 boxes
//#define  YFEDCSIZE  2100 // 9*21 boxes
#define  XFEDCSIZE  140  // 14 boxes
#define  YFEDCSIZE  1890 // 9*21 boxes
*/

#define  NUMPSUCH_INROW 18
#define  NUMPSUCRATE_INCOLUMN 5
#define  NUMPSURACK_INCOLUMN 6
#define  NUMPSURACK_INROW 5
#define  XPSURSIZE  150 // (5)*1.5 boxes
#define  YPSURSIZE  360 // 18 boxes 
#define  XPSUOFFSET 50
#define  YPSUOFFSET 100

#define  NUMFEDCH_INCOLUMN 12
#define  NUMFEDCH_INROW 8
#define  NUMFED_INCOLUMN 21
#define  NUMFED_INROW 1
//#define  NUMFEDCRATE_INCOLUMN 11
//#define  NUMFEDCRATE_INROW 3
#define  NUMFEDCRATE_INCOLUMN 1
#define  NUMFEDCRATE_INROW 31
//#define  XFEDCSIZE  160  // 14 boxes
//#define  YFEDCSIZE  2100 // 9*21 boxes
#define  XFEDCSIZE  2940  // 14*21 boxes
#define  YFEDCSIZE  90 // 9 boxes
#define  XFEDOFFSET 150
#define  YFEDOFFSET 100

class TmModule;
class TmApvPair;
class EventSetup;
class TmCcu;
class TmPsu;

class TrackerMap {
 public:
  //TrackerMap(){TrackerMap(" ");};   //!< default constructor
  TrackerMap(std::string s=" ",int xsize1=340,int ysize1=200);
  TrackerMap(const edm::ParameterSet & iConfig);
  TrackerMap(const edm::ParameterSet & iConfig,const SiStripFedCabling* tkFed);
  ~TrackerMap();  
  
  void build();
  void init();
  void drawModule(TmModule * mod, int key, int layer, bool total, std::ofstream * file);
  void print(bool print_total=true,float minval=0., float maxval=0.,std::string s="svgmap");
  void printall(bool print_total=true,float minval=0., float maxval=0.,std::string s="svgmap",int width=6000, int height=3200);
  void printonline();
  void printlayers(bool print_total=true,float minval=0., float maxval=0.,std::string s="layer");
  void save(bool print_total=true,float minval=0., float maxval=0.,std::string s="svgmap.svg",int width=1500, int height=800);
  void save_as_fedtrackermap(bool print_total=true,float minval=0., float maxval=0.,std::string s="fed_svgmap.svg",
                 int width=YFEDOFFSET+(YFEDCSIZE+YFEDOFFSET)*NUMFEDCRATE_INROW+300,
                 int height=XFEDOFFSET+(XFEDCSIZE+XFEDOFFSET)*NUMFEDCRATE_INCOLUMN+300);
  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);
  void save_as_psutrackermap(bool print_total=true,float minval=0., float maxval=0.,std::string s="psu_svgmap.svg",
                 int width=YPSUOFFSET+(YPSURSIZE+YPSUOFFSET)*NUMPSURACK_INROW+300, 
                 int height=XPSUOFFSET+(XPSURSIZE+XPSUOFFSET)*NUMPSURACK_INCOLUMN+300);
  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);
  void drawApvPair( int crate, int numfed_incrate, bool total, TmApvPair* apvPair,std::ofstream * file,bool useApvPairValue);
  void drawCcu( int crate, int numfed_incrate, bool total, TmCcu* ccu,std::ofstream * file,bool useCcuValue);
  void drawPsu(int rack,int numcrate_inrack, bool print_total, TmPsu* psu,std::ofstream * svgfile,bool usePsuValue);
  void drawHV2(int rack,int numcrate_inrack, bool print_total, TmPsu* psu,std::ofstream * svgfile,bool usePsuValue);
  void drawHV3(int rack,int numcrate_inrack, bool print_total, TmPsu* psu,std::ofstream * svgfile,bool usePsuValue);
  void fill_current_val(int idmod, float current_val );
  void fill(int layer , int ring, int nmod, float x );
  void fill(int idmod, float qty );
  void fillc(int idmod, int RGBcode) {fillc(idmod,(RGBcode>>16) & 0xFF , (RGBcode>>8) & 0xFF, RGBcode & 0xFF);}
  void fillc(int idmod, int red, int green, int blue);
  void fillc(int layer,int ring, int nmod, int red, int green, int blue);
  void fillc_all_blank();
  void fill_all_blank();
  void fill_current_val_fed_channel(int fedId,int fedCh, float current_val );
  void fill_fed_channel(int fedId,int fedCh, float qty );
  void fill_fed_channel(int modId, float qty );
  void fillc_fed_channel(int fedId,int fedCh, int red, int green, int blue);
  void fillc_fec_channel(int crate,int slot, int ring, int addr, int red, int green, int blue  );
  void fill_fec_channel(int crate,int slot, int ring, int addr, float qty  );
  void fill_lv_channel(int rack,int crate, int board, float qty  );
  void fillc_lv_channel(int rack,int crate, int board, int red, int green, int blue);
  void fill_hv_channel2(int rack,int crate, int board, float qty  );
  void fillc_hv_channel2(int rack,int crate, int board, int red, int green, int blue);
  void fill_hv_channel3(int rack,int crate, int board, float qty  );
  void fillc_hv_channel3(int rack,int crate, int board, int red, int green, int blue);
  int module(int fedId,int fedCh);
  void setText(int idmod , std::string s );
  void setText(int layer, int ring, int nmod , std::string s );
  void setPalette(int numpalette){palette=numpalette;} 
  void drawPalette(std::ofstream * file, int xoffset=3660, int yoffset=1540); 
  void showPalette(bool printflag1){printflag=printflag1;}; 
  void setTitle(std::string s){title=s;};
  void setRange(float min,float max);
  std::pair<float,float>getAutomaticRange();
  void addPixel(bool addPixelfl){addPixelFlag=addPixelfl;};
  void onlyPixel(bool onlyPixelfl){onlyPixelFlag=onlyPixelfl;};
  void reset();
  void load(std::string s="tmap.svg"); 
  int getxsize(){return xsize;};
  int getysize(){return ysize;};
  int getcolor(float value, int palette);
  std::ifstream * findfile(std::string filename);
  int getNumMod(){return number_modules;};
  std::vector<TColor*> vc; 
  typedef std::map<const int  , TmModule *> SmoduleMap;
  SmoduleMap smoduleMap;
  typedef std::map<const int  , TmModule *> ImoduleMap;
  ImoduleMap imoduleMap;
  typedef std::map<const int  , TmApvPair*> SvgApvPair;
  SvgApvPair apvMap;
  typedef std::multimap<const int  , TmApvPair*> ModApvPair;
   ModApvPair apvModuleMap;
  typedef std::map<const int  , int>  SvgFed;
  SvgFed fedMap;
  SvgFed slotMap;
  typedef std::map<const int  , TmCcu*> MapCcu;
  MapCcu  ccuMap;
  typedef std::multimap<TmCcu*  , TmModule*> FecModule;
  FecModule fecModuleMap;
  typedef std::map<const int  , TmPsu*> MapPsu;
  MapPsu  psuMap;
  typedef std::multimap<TmPsu*  , TmModule*> PsuModule;
  PsuModule psuModuleMap;
  int palette;
  bool printflag;
  bool saveWebInterface;
  bool saveGeoTrackerMap;
  bool enableFedProcessing;
  bool enableFecProcessing;
  bool enableLVProcessing;
  bool enableHVProcessing;
  bool tkMapLog;
  int ndet; //number of detectors 
  int npart; //number of detectors parts 
  std::string title;
   std::string jsfilename,infilename;
  std::string jsPath;
   bool psetAvailable;
  double phival(double x, double y){
    double phi;
    double phi1=atan(y/x);
    phi = phi1;
    if(y<0. && x>0) phi = phi1+2.*M_PI;
    if(x<0.)phi=phi1+M_PI;
    if(fabs(y)<0.000001 && x>0)phi=0;
    if(fabs(y)<0.000001&&x<0)phi=M_PI;
    if(fabs(x)<0.000001&&y>0)phi=M_PI/2.;
    if(fabs(x)<0.000001&&y<0)phi=3.*M_PI/2.;
      
    return phi;
  }
  
  int find_layer(int ix, int iy)
    {
      int add;
      int layer=0;
      if(iy <= xsize){//endcap+z
        add = 15;
    layer = ix/ysize;
    layer = layer+add+1;
      }
      if(iy > xsize && iy< 3*xsize){//barrel
    add=30;
    if(ix < 2*ysize){
      layer=1;
    }else {
      layer = ix/(2*ysize);
      if(iy < 2*xsize)layer=layer*2+1; else layer=layer*2;
        }
    layer = layer+add;
      }
      if(iy >= 3*xsize){    //endcap-z
    layer = ix/ysize;
    layer = 15-layer;
      }
      return layer;  
    }

  int getlayerCount(int subdet, int partdet){
    int ncomponent=0;
    if(subdet == 1){ //1=pixel
      if(partdet == 1 || partdet == 3){ //1-3=encap
    ncomponent = 3;
      }
      else { ncomponent = 3; } //barrel
    }
    if(subdet== 2){ //2=inner silicon
      if(partdet == 1 || partdet == 3){ //1-3=encap
    ncomponent = 3;
      }
      else { ncomponent = 4; } //barrel
    }
    if(subdet== 3){ //3=outer silicon
      if(partdet == 1 || partdet == 3){ //1-3=encap
    ncomponent = 9;
      }
      else { ncomponent = 6; } //barrel
    }
    return(ncomponent);
  }   
  double  xdpixel(double x){
    double res;
    if(saveAsSingleLayer)res= ((x-xmin)/(xmax-xmin)*xsize);
    else res= ((x-xmin)/(xmax-xmin)*xsize)+ix;
    return res;
  }
  double  ydpixel(double y){
    double res=0;
    double y1;
    y1 = (y-ymin)/(ymax-ymin);
    if(nlay>30)
       {
        if(nlay <34) res= 2*ysize - (y1*2*ysize);
        if(nlay==34) res= 2.4*ysize - (y1*2.4*ysize);
        if(nlay>34) res= 2.5*ysize - (y1*2.5*ysize);  
        }
    else res= xsize - (y1*xsize);
    if(!saveAsSingleLayer) res=res+iy;
    return res;
  }
  double  xdpixelc(double x){
    double res;
    if(saveAsSingleLayer)res= ((x-xmin)/(xmax-xmin)*XFEDCSIZE);
    else res= ((x-xmin)/(xmax-xmin)*XFEDCSIZE)+ix;
    return res;
  }
  double  ydpixelc(double y){
    double res;
    double y1;
    y1 = (y-ymin)/(ymax-ymin);
     if(saveAsSingleLayer)res= YFEDCSIZE - (y1*YFEDCSIZE);
     else res= YFEDCSIZE - (y1*YFEDCSIZE)+iy;
    return res;
  }
  double  xdpixelfec(double x){
    double res;
    if(saveAsSingleLayer)res= ((x-xmin)/(xmax-xmin)*xsize);
    else res= ((x-xmin)/(xmax-xmin)*xsize)+ix;
    return res;
  }
  double  ydpixelfec(double y){
    double res;
    double y1;
    y1 = (y-ymin)/(ymax-ymin);
     if(saveAsSingleLayer)res= 2*ysize - (y1*2*ysize);
     else res= 2*ysize - (y1*2*ysize)+iy;
    return res;
  }
  double  xdpixelpsu(double x){
    double res;
    if(saveAsSingleLayer)res= ((x-xmin)/(xmax-xmin)*XPSURSIZE);
    else res= ((x-xmin)/(xmax-xmin)*XPSURSIZE)+ix;
    return res;
  }
   double  ydpixelpsu(double y){
    double res;
    double y1;
    y1 = (y-ymin)/(ymax-ymin);
     if(saveAsSingleLayer)res=YPSURSIZE - (y1*YPSURSIZE);
     else res= YPSURSIZE - (y1*YPSURSIZE)+iy;
    return res;
  }

   void defcwindow(int num_crate){
     //    ncrate = num_crate;
     int xoffset=XFEDOFFSET;
    int yoffset=YFEDOFFSET;
    xmin=0.;xmax=(NUMFEDCH_INCOLUMN+2)*NUMFED_INCOLUMN;  ymin = 0.; ymax=(NUMFEDCH_INROW+1)*NUMFED_INROW;

    ix = xoffset+((NUMFEDCRATE_INCOLUMN-1)-((num_crate-1)%NUMFEDCRATE_INCOLUMN))*(XFEDCSIZE+XFEDOFFSET);
    iy = yoffset+((num_crate-1)/NUMFEDCRATE_INCOLUMN)*(YFEDCSIZE+YFEDOFFSET);
  } 
   void deffecwindow(int num_crate){
     //    ncrate = num_crate;
    int xoffset=xsize/3;
    int yoffset=2*ysize;
    xmin=-1.;xmax=37.;  ymin = -10.; ymax=40.;
    if(num_crate==1||num_crate==3)ix = xoffset+xsize*2;
    if(num_crate==2||num_crate==4)ix = xoffset;
    iy = yoffset+((num_crate-1)/2)*ysize*4;
  }
   void defpsuwindow(int num_rack){
     //    nrack = num_rack;
    int xoffset=XPSUOFFSET;
    int yoffset=YPSUOFFSET;
    xmin=0; xmax=(NUMPSUCRATE_INCOLUMN)*1.5;
    ymin=0; ymax=NUMPSUCH_INROW;

    ix = xoffset+((NUMPSURACK_INCOLUMN-1)-((num_rack-1)%NUMPSURACK_INCOLUMN))*(XPSURSIZE+XPSUOFFSET);
    iy = yoffset+((num_rack-1)/NUMPSURACK_INCOLUMN)*(YPSURSIZE+YPSUOFFSET);
    }


void defwindow(int num_lay){
  // nlay = num_lay;
  if(posrel){ // separated modules
    xmin=-2.;ymin=-2.;xmax=2.;ymax=2.;
    if(num_lay >12 && num_lay < 19){
      xmin=-.40;xmax=.40;ymin=-.40;ymax=.40;
    }
    if(num_lay>30){
      xmin=-0.1;xmax=3.;ymin=-0.1;ymax=8.5;
      if(num_lay<34){xmin=-0.3;xmax=1.0;}
      if(num_lay>33&&num_lay<38){xmax=2.0;}
      if(num_lay>37){ymax=8.;}//inner
    }
  }else{ //overlayed modules
    xmin=-1.3;ymin=-1.3;xmax=1.3;ymax=1.3;
    if(num_lay >12 && num_lay < 19){
      xmin=-.20;xmax=.20;ymin=-.20;ymax=.20;
    }
    if(num_lay>30){
      xmin=-1.5;xmax=1.5;ymin=-1.;ymax=28.;
      if(num_lay<34){xmin=-0.5;xmax=0.5;}
      if(num_lay>33&&num_lay<38){xmin=-1.;xmax=1.;}
    }
    
  }
  if(num_lay<16){
      ix=0;
      if(num_lay==15||num_lay==14)iy=(15-num_lay)*2*ysize; else 
          {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);}}
  if(num_lay>15&&num_lay<31){
    ix=3*xsize;
     if(num_lay==16||num_lay==17)iy=(num_lay-16)*2*ysize; else 
          {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);}}
  if(num_lay>30){
    if(num_lay==31){ix=(int)(1.5*xsize);iy=0;}
    if(num_lay==32){int il=(num_lay-30)/2;ix=xsize;iy=il*2*ysize;}
    if(num_lay==33){int il=(num_lay-30)/2;ix=2*xsize;iy=il*2*ysize;}
    if(num_lay==34){int il=(num_lay-30)/2;ix=xsize;iy=il*(int)(2.57*ysize);}
    if(num_lay>34 && num_lay%2==0){int il=(num_lay-30)/2;ix=xsize;iy=il*(int)(2.5*ysize);}
    if(num_lay>34 && num_lay%2!=0){int il=(num_lay-30)/2;ix=2*xsize;iy=il*(int)(2.5*ysize);}
  }
}
  
  int getringCount(int subdet, int partdet, int layer){
    int ncomponent=0;
    if(subdet== 1){ //1=pixel
      if(partdet== 1 || partdet== 3){ //end-cap
    ncomponent = 7;
      }
      else{ncomponent = 8;} //barrel
    }   
    if(subdet== 2){ //inner-silicon
      if(partdet== 1 || partdet== 3){ //end-cap
    ncomponent = 3;
      }
      else{ncomponent = 12;} //barrel
    }
    if(subdet== 3){ //outer-silicon
      if(partdet== 1){ //end-cap-z
    if (layer== 1) ncomponent = 4;
    if (layer== 2 || layer== 3) ncomponent = 5;
    if (layer== 4 || layer== 5 || layer== 6) ncomponent = 6;
    if (layer== 7 || layer== 8 || layer== 9) ncomponent = 7;
      }
      if(partdet== 3){ //endcap+z
    if (layer== 9) ncomponent = 4;
    if (layer== 8 || layer== 7) ncomponent = 5;
    if (layer== 6 || layer== 5 || layer== 4) ncomponent = 6;
    if (layer== 3 || layer== 2 || layer== 1) ncomponent = 7;
      }
      if(partdet== 2){ //barrel
    ncomponent = 12;
      }
    }
    return(ncomponent);
  }
  int getmoduleCount(int subdet, int partdet, int layer, int ring){
    int ncomponent=0;
    int spicchif[] ={24,24,40,56,40,56,80};
    int spicchib[] ={20,32,44,30,38,46,56,42,48,54,60,66,74};
    int numero_layer = 0;
    
    if(partdet == 2){ //barrel
      numero_layer = layer-1;
      if(subdet== 2){ //inner
    numero_layer = numero_layer+3;
      }
      if(subdet == 3){ //outer
    numero_layer = numero_layer+7;
      }
      ncomponent = spicchib[numero_layer];
    }
    if(partdet!= 2){ //endcap
      if(subdet== 1)ncomponent=24;//pixel
      else
    ncomponent = spicchif[ring-1];
    }
    return(ncomponent);
  }
  static int layerno(int subdet,int leftright,int layer){
    if(subdet==6&&leftright==1)return(10-layer);
    if(subdet==6&&leftright==2)return(layer+21);
    if(subdet==4&&leftright==1)return(4-layer+9);
    if(subdet==4&&leftright==2)return(layer+18);
    if(subdet==2&&leftright==1)return(4-layer+12);
    if(subdet==2&&leftright==2)return(layer+15);
    if(subdet==1)return(layer+30);
    if(subdet==3)return(layer+33);
    if(subdet==5)return(layer+37);
    assert(false);
  }
  
  static bool isRingStereo(int key){
    int layer=key/100000;
    int ring = key - layer*100000;
    ring = ring/1000;
    if(layer==34 || layer==35 || layer==38 || layer==39) return true;
    if(layer<13 || (layer>18&&layer<31))
      if(ring==1 || ring==2 || ring==5)return true;
    return false;
  }
  int nlayer(int det,int part,int lay){
    if(det==3 && part==1) return lay;
    if(det==2 && part==1) return lay+9;
    if(det==1 && part==1) return lay+12;
    if(det==1 && part==3) return lay+15;
    if(det==2 && part==3) return lay+18;
    if(det==3 && part==3) return lay+21;
    if(det==1 && part==2) return lay+30;
    if(det==2 && part==2) return lay+33;
    if(det==3 && part==2) return lay+37;
    return -1; 
  }
  
  std::string layername(int layer){
    std::string s= " ";
    std::ostringstream ons;
    
    if(layer < 10) ons << "TEC -z Layer " << layer;
    if(layer < 13 && layer > 9) ons << "TID -z Layer " << layer-9;
    if(layer < 16 && layer > 12) ons << "FPIX -z Layer " << layer-12;
    if(layer < 19 && layer > 15) ons << "FPIX +z Layer " << layer-15;
    if(layer < 22 && layer > 18) ons << "TID +z Layer " << layer-18;
    if(layer < 31 && layer > 21) ons << "TEC +z Layer " << layer-21;
    if(layer < 34 && layer > 30) ons << "TPB Layer " << layer-30;
    if(layer < 38 && layer > 33) ons << "TIB Layer " << layer-33;
    if(layer > 37) ons << "TOB Layer " << layer-37;
    s = ons.str(); 
    return s;  
  }
  int ntotRing[43];
  int firstRing[43];
  
 protected:
  int nlay;
  //  int ncrate;
  //  int nrack;
  int ncrates;
  int firstcrate;
  int nfeccrates;
  int npsuracks;
  double xmin,xmax,ymin,ymax;
  int xsize,ysize,ix,iy;
  bool posrel;
  bool firstcall;
  std::ofstream * svgfile;
  std::ofstream * savefile;
  std::ifstream * jsfile;
  std::ifstream * inputfile;
  std::ifstream * ccufile;
  float gminvalue,gmaxvalue;
  float minvalue,maxvalue;
  int number_modules;
  bool temporary_file; 
  
 private:
  
  float oldz;
  bool saveAsSingleLayer;
  bool addPixelFlag;
  bool onlyPixelFlag;
};
#endif