#ifndef muonfixedid_h
#define muonfixedid_h
/* A bunch of utility functions to convert a MuonFixedID to ordinary
chamber info.  Code adapted from Athena MuonFixedID.h 
Made these a bunch of independent functions, rather than part of a class.
The "Muon fixed ID" is passed/returned to/from functions
Got rid of all the "index" functions - combined them in other functions.
Defined a new station 35 "GAS" which is the UM MDT gas monitoring chamber.
  Edward Diehl 8-May-2007
*/
#include <iostream.h>
#include <string.h>

static const int kTechnologyMask   = 3;
static const int kTechnologyShift  = 30;
static const int kTechnologyMin    = 0;

static const int kStationNameMask  = 63;
static const int kStationNameShift = 24;
static const int kStationNameMin   = 1;

static const int kStationEtaMask   = 31;
static const int kStationEtaShift  = 19;
static const int kStationEtaMin    = -8;

static const int kStationPhiMask   = 63;
static const int kStationPhiShift  = 13;
static const int kStationPhiMin    = 1;

//   Mdt specific code 
static const int kMdtMultilayerMask    = 1;
static const int kMdtMultilayerShift   = 9;
static const int kMdtMultilayerMin     = 1;

static const int kMdtTubeLayerMask     = 3;
static const int kMdtTubeLayerShift    = 7;
static const int kMdtTubeLayerMin      = 1;

static const int kMdtTubeMask          = 127;
static const int kMdtTubeShift         = 0;
static const int kMdtTubeMin           = 1;

//  Rpc specific code
static const int kRpcDoubletRMask      = 1;
static const int kRpcDoubletRShift     = 12; 
static const int kRpcDoubletRMin       = 1;
static const int kRpcDoubletZMask      = 3;
static const int kRpcDoubletZShift     = 10; 
static const int kRpcDoubletZMin       = 1;
static const int kRpcDoubletPhiMask    = 1;
static const int kRpcDoubletPhiShift   = 9; 
static const int kRpcDoubletPhiMin     = 1;
static const int kRpcGasGapMask        = 1;
static const int kRpcGasGapShift       = 8;  
static const int kRpcGasGapMin         = 1;
static const int kRpcMeasuresPhiMask   = 1;
static const int kRpcMeasuresPhiShift  = 7;  
static const int kRpcMeasuresPhiMin    = 0;
static const int kRpcStripMask         = 127;
static const int kRpcStripShift        = 0; 
static const int kRpcStripMin          = 1;

// Tgc specific code 
static const int kTgcGasGapMask        = 3;
static const int kTgcGasGapShift       = 9;
static const int kTgcGasGapMin         = 1;
static const int kTgcIsStripMask       = 1;
static const int kTgcIsStripShift      = 8;
static const int kTgcIsStripMin        = 0;
static const int kTgcChannelMask       = 255;
static const int kTgcChannelShift      = 0;
static const int kTgcChannelMin        = 1;

//  Csc specific code
static const int kCscChamberLayerMask  = 1;
static const int kCscChamberLayerShift = 11;
static const int kCscChamberLayerMin   = 1;
static const int kCscWireLayerMask     = 3;
static const int kCscWireLayerShift    = 9;
static const int kCscWireLayerMin      = 1;
static const int kCscMeasuresPhiMask   = 1;
static const int kCscMeasuresPhiShift  = 8;
static const int kCscMeasuresPhiMin    = 0;
static const int kCscStripMask         = 255;
static const int kCscStripShift        = 0;
static const int kCscStripMin          = 1;

/*****************************************************************
*  List of general routines
*    mfid == Muon Fixed ID
******************************************************************/
int StationID(int mfid);               //returns station ID  [-1,1..34]
int StationEta(int mfid);              //returns station eta [-8..8]
int StationPhi(int mfid);              //returns station phi [1..9]
int SetStationID( int id, int mfid );  //returns mfid with station id set
int SetStationEta( int id, int mfid ); //returns mfid with eta set
int SetStationPhi( int id, int mfid ); //returns mfid with phi set
char *ChamberType(int station);        //returns 3 letter station type (e.g. "BIL")
int ChamberType( char *station );      //returns integer type given 3 letter station type

/*****************************************************************
*  List of MDT routines
*    mfid == Muon Fixed ID
******************************************************************/
void ChamberName(int mfid, char *c);   //writes MDT chambername on c (e.g BML4A13)
void TubeName(int mfid, char *c);      //writes MDT tube name: chamber-ml-l-t on c
int MdtML(int mfid);                   //returns MDT multilayer
int MdtLayer(int mfid);                //returns MDT layer
int MdtTube(int mfid);                 //returns MDT tube number
int SetMdtML( int ml, int mfid );      //returns mfid with MDT multilayer set
int SetMdtLayer( int l, int mfid );    //returns mfid with MDT layer set
int SetMdtTube( int t, int mfid );     //returns mfid with MDT tube set
int SetMdtID( char *chamber, int ml, int ly, int tb ); //returns mfid MDT chamber ml-layer-tube

/*****************************************************************
*  List of RPC routines
*    mfid == Muon Fixed ID
******************************************************************/
void RpcName(int mfid, char *c);      //writes RPC name (guess)
void RpcChamber(int mfid, char *c);   //writes RPC chamber (guess)
int rpcDoubletR(int mfid);      //returns RPC doublet R
int rpcDoubletZ(int mfid);      //returns RPC doublet Z
int rpcDoubletPhi(int mfid);    //returns RPC doublet Phi
int rpcGasGap(int mfid);        //returns RPC gas gap
int rpcMeasuresPhi(int mfid);   //returns RPC measures phi (?)
int rpcStrip(int mfid);         //returns RPC strip

int setRpcDoubletR( int num, int mfid );
int setRpcDoubletR( int num, int mfid );
int setRpcDoubletZ( int num, int mfid );
int setRpcDoubletPhi( int num, int mfid );
int setRpcGasGap( int num, int mfid );
int setRpcMeasuresPhi( int num, int mfid );
int setRpcStrip( int num, int mfid );

/*****************************************************************
*  List of TGC routines
*    mfid == Muon Fixed ID
******************************************************************/
void TgcName(int mfid, char *c);      //writes full TGC name (guess)
void TgcChamber(int mfid, char *c);   //writes TGC chamber name (guess)
int tgcGasGap(int mfid);
int tgcIsStrip(int mfid);
int tgcChannel(int mfid);
int setTgcGasGap( int num, int mfid );
int setTgcIsStrip( int num, int mfid );
int setTgcChannel( int num, int mfid );

/*****************************************************************
*  List of CSC routines
*    mfid == Muon Fixed ID
******************************************************************/
void Csc(int mfid, char *c);      //writes CSC name (guess)
int cscChamberLayer(int mfid);
int cscWireLayer(int mfid);
int cscMeasuresPhi(int mfid);
int cscStrip(int mfid);
int setCscChamberLayer( int num, int mfid );
int setCscWireLayer( int num, int mfid );
int setCscMeasuresPhi( int num, int mfid );
int setCscStrip( int num, int mfid );

/*****************************************************************
*  General routines
******************************************************************/
int StationID(int mfid) {
  return ((mfid >> kStationNameShift) & kStationNameMask) + kStationNameMin;
}
int StationEta(int mfid) {
  return ((mfid >> kStationEtaShift) & kStationEtaMask) + kStationEtaMin;
}
//  This returns the PHI as defined in Athena (phi=1 is at top of detector?)
int StationPhi(int mfid) {
  return ((mfid >> kStationPhiShift) & kStationPhiMask) + kStationPhiMin;
}
//  This returns the PHI as defined in the TDR
//int StationPhi(int mfid) {
//  int iphi;
//  iphi = ((mfid >> kStationPhiShift) & kStationPhiMask) + kStationPhiMin + 4;
//  if( iphi > 16 ) iphi -= 16;
//  return iphi;
//}
char *ChamberType(int station) {
  if(station ==  1 ) return "BIL";
  if(station ==  2 ) return "BIS";
  if(station ==  3 ) return "BML";
  if(station ==  4 ) return "BMS";
  if(station ==  5 ) return "BOL";
  if(station ==  6 ) return "BOS";
  if(station ==  7 ) return "BEE";
  if(station ==  8 ) return "BIR";
  if(station ==  9 ) return "BMF";
  if(station == 10 ) return "BOF";
  if(station == 11 ) return "BOG";
  if(station == 12 ) return "BOH";
  if(station == 13 ) return "BIM";
  if(station == 14 ) return "EIC";
  if(station == 15 ) return "EIL";
  if(station == 16 ) return "EEL";
  if(station == 17 ) return "EES";
  if(station == 18 ) return "EMC";
  if(station == 19 ) return "EML";
  if(station == 20 ) return "EMS";
  if(station == 21 ) return "EOC";
  if(station == 22 ) return "EOL";
  if(station == 23 ) return "EOS";
  if(station == 24 ) return "EIS";
  if(station == 25 ) return "T1F";
  if(station == 26 ) return "T1E";
  if(station == 27 ) return "T2F";
  if(station == 28 ) return "T2E";
  if(station == 29 ) return "T3F";
  if(station == 30 ) return "T3E";
  if(station == 31 ) return "T4F";
  if(station == 32 ) return "T4E";
  if(station == 33 ) return "CSS";
  if(station == 34 ) return "CSL";
  if(station == 35 ) return "GAS";
  else return "XXX" ;
}

int ChamberType( char *station ) {
  if( strcmp(station,"BIL") == 0 ) return 1;
  if( strcmp(station,"BIS") == 0 ) return 2;
  if( strcmp(station,"BML") == 0 ) return 3;
  if( strcmp(station,"BMS") == 0 ) return 4;
  if( strcmp(station,"BOL") == 0 ) return 5;
  if( strcmp(station,"BOS") == 0 ) return 6;
  if( strcmp(station,"BEE") == 0 ) return 7;
  if( strcmp(station,"BIR") == 0 ) return 8;
  if( strcmp(station,"BMF") == 0 ) return 9;
  if( strcmp(station,"BOF") == 0 ) return 10;
  if( strcmp(station,"BOG") == 0 ) return 11;
  if( strcmp(station,"BOH") == 0 ) return 12;
  if( strcmp(station,"BIM") == 0 ) return 13;
  if( strcmp(station,"EIC") == 0 ) return 14;
  if( strcmp(station,"EIL") == 0 ) return 15;
  if( strcmp(station,"EEL") == 0 ) return 16;
  if( strcmp(station,"EES") == 0 ) return 17;
  if( strcmp(station,"EMC") == 0 ) return 18;
  if( strcmp(station,"EML") == 0 ) return 19;
  if( strcmp(station,"EMS") == 0 ) return 20;
  if( strcmp(station,"EOC") == 0 ) return 21;
  if( strcmp(station,"EOL") == 0 ) return 22;
  if( strcmp(station,"EOS") == 0 ) return 23;
  if( strcmp(station,"EIS") == 0 ) return 24;
  if( strcmp(station,"T1F") == 0 ) return 25;
  if( strcmp(station,"T1E") == 0 ) return 26;
  if( strcmp(station,"T2F") == 0 ) return 27;
  if( strcmp(station,"T2E") == 0 ) return 28;
  if( strcmp(station,"T3F") == 0 ) return 29;
  if( strcmp(station,"T3E") == 0 ) return 30;
  if( strcmp(station,"T4F") == 0 ) return 31;
  if( strcmp(station,"T4E") == 0 ) return 32;
  if( strcmp(station,"CSS") == 0 ) return 33;
  if( strcmp(station,"CSL") == 0 ) return 34;
  if( strcmp(station,"GAS") == 0 ) return 35;
  if( strcmp(station,"XXX") == 0 ) return -1;
  return -1;
}

int SetStationID( int id, int mfid ) {
  id -= kStationNameMin;
  if ( id > kStationNameMask ) {
    cout << "Error SetStationID bad id=" << id << endl; 
    return mfid;
   }
   mfid &= ~(kStationNameMask << kStationNameShift);
   mfid |= (id & kStationNameMask) << kStationNameShift;
   return mfid;
}

int SetStationEta( int id, int mfid ) {
  id -= kStationEtaMin;
  if ( id > kStationEtaMask ) {
    cout << "Error SetStationEta bad id=" << id << endl; 
    return mfid;
  }
  mfid &= ~(kStationEtaMask << kStationEtaShift);
  mfid |= (id & kStationEtaMask) << kStationEtaShift;
  return mfid;
}

int SetStationPhi( int id, int mfid ) {
  id -= kStationPhiMin;
  if ( id > kStationPhiMask ) {
    cout << "Error SetStationPhi bad id =" << id << endl; 
    return mfid;
  }
  mfid &= ~(kStationPhiMask << kStationPhiShift);
  mfid |= (id & kStationPhiMask) << kStationPhiShift;
  return mfid;
}

/*****************************************************************
*  MDT routines
******************************************************************/
//  Writes the ATLAS chamber name for a given MuonFixedID
void ChamberName(int mfid, char *cname) {
  char cend, ctype[4];  
  int sid  = StationID(mfid);
  sprintf(ctype,"%s",ChamberType(sid));
  int iphi = StationPhi(mfid);
  int ieta = StationEta(mfid);
//  Convert from software phi to hardware phi
//  Software: both L, S chambers Phi = [1,8]
//  Hardware: Phi = [1,16] L=odd, S=even
  if( ctype[2] == 'L' ) iphi = 2*iphi - 1;
  else                  iphi = 2*iphi;
//  Convert eta to A/C ends
//  Is this valid for endcap chambers
  if( ieta < 0 ) { 
    ieta = -ieta;
    cend = 'C';
  } else {
    cend = 'A';
  }
  sprintf(cname,"%s%i%c%2.2i",ctype,ieta,cend,iphi);
  return;
}

//  Writes the ATLAS chamber name-ML-LAYER-TUBE for a given MuonFixedID
void TubeName(int mfid, char *fcname) {
  char cname[8];  
  ChamberName( mfid, cname );
  int ml    = MdtML(mfid);
  int layer = MdtLayer(mfid);
  int tube  = MdtTube(mfid);
  sprintf(fcname,"%s-%i-%i-%i",cname,ml,layer,tube);
  return;
}

int MdtML(int mfid) {
  return ((mfid >> kMdtMultilayerShift) & kMdtMultilayerMask) + kMdtMultilayerMin;
}
int MdtLayer(int mfid) {
   return ((mfid >> kMdtTubeLayerShift) & kMdtTubeLayerMask) + kMdtTubeLayerMin;
}
int MdtTube(int mfid) {
  return ((mfid >> kMdtTubeShift) & kMdtTubeMask) + kMdtTubeMin;
}

int SetMdtML( int ml, int mfid ) {
  ml -= kMdtMultilayerMin;
  if ( ml > kMdtMultilayerMask ) {
    cout << "Error SetMdtML bad ML number=" << ml << endl; 
    return mfid;
  }
  mfid &= ~(kMdtMultilayerMask << kMdtMultilayerShift);
  mfid |= (ml & kMdtMultilayerMask) << kMdtMultilayerShift;
  return mfid;
}

int SetMdtLayer( int l, int mfid ) {
  l -= kMdtTubeLayerMin;
  if ( l > kMdtTubeLayerMask ) {
    cout << "Error SetMdtLayer bad layer number=" << l << endl; 
    return mfid;
  }
  mfid &= ~(kMdtTubeLayerMask << kMdtTubeLayerShift);
  mfid |= (l & kMdtTubeLayerMask) << kMdtTubeLayerShift;
  return mfid;
}

int SetMdtTube( int t, int mfid ) {
  t -= kMdtTubeMin;
  if ( t > kMdtTubeMask ) {
    cout << "Error SetMdtTube bad tube number=" << t << endl; 
    return mfid;
  }
  mfid &= ~(kMdtTubeMask << kMdtTubeShift);
  mfid |= (t & kMdtTubeMask) << kMdtTubeShift;
  return mfid;
}

//  Ed's routine to set the entire MDT fixed ID
int SetMdtID( char *chamber, int ml, int ly, int tb ) {
  int mfid=0;
  char *station="EML",chphi[3],cheta[2];
  int i,iphi,ieta;
  
  for( i=0; i<3; i++ ) station[i] = chamber[i];
  cout<<station<<" "<<ChamberType(station)<<"\n";
  if( chamber[5] == '0' ) sprintf(chphi,"%c",chamber[6]);
  else                    sprintf(chphi,"%c%c",chamber[5],chamber[6]);
  if( chamber[2] == 'L' || chamber[2] == 'l' ) iphi = (atoi(chphi) + 1)/2;
  else iphi = atoi(chphi)/2;
  sprintf(cheta,"%c",chamber[3]);
  ieta = atoi(cheta);
  if(chamber[4]=='C' || chamber[4]=='c') ieta = -ieta;
    
  mfid = SetStationID( ChamberType(station), mfid );
  mfid = SetStationEta( ieta, mfid );
  mfid = SetStationPhi( iphi, mfid );
  mfid = SetMdtML( ml, mfid );
  mfid = SetMdtLayer( ly, mfid );
  mfid = SetMdtTube( tb, mfid );

  return mfid;
}

/*****************************************************************
*  RPC routines
******************************************************************/
//  Writes the full RPC chamber name for a given MuonFixedID
void RpcName(int mfid, char *cname) {
  char cend, ctype[4];  
  int sid = StationID(mfid);
  sprintf(ctype,"%s",ChamberType(sid));
  int igap     = rpcGasGap(mfid);
  int istrip   = rpcStrip(mfid);
  int iphi = StationPhi(mfid);
  int ieta = StationEta(mfid);
//  Convert from software phi to hardware phi
  if( ctype[2] == 'L' ) iphi = 2*iphi - 1;
  else                  iphi = 2*iphi;
//  Convert eta to A/C ends
//  Will need to add code for endcap chambers
  if( ieta < 0 ) { 
    ieta = -ieta;
    cend = 'C';
  } else {
    cend = 'A';
  }
  sprintf(cname,"%s%i%c%2.2i-%i-%i",ctype,ieta,cend,iphi,igap,istrip);
  return;
}
//  Writes the RPC chamber name for a given MuonFixedID
void RpcChamber(int mfid, char *cname) {
  char cend, ctype[4];  
  int sid = StationID(mfid);
  sprintf(ctype,"%s",ChamberType(sid));
  int iphi = StationPhi(mfid);
  int ieta = StationEta(mfid);
//  Convert from software phi to hardware phi
  if( ctype[2] == 'L' ) iphi = 2*iphi - 1;
  else                  iphi = 2*iphi;
//  Convert eta to A/C ends
  if( ieta < 0 ) { 
    ieta = -ieta;
    cend = 'C';
  } else {
    cend = 'A';
  }
  sprintf(cname,"%s%i%c%2.2i",ctype,ieta,cend,iphi);
  return;
}

int rpcDoubletR(int mfid) {
  return ((mfid >> kRpcDoubletRShift) & kRpcDoubletRMask) + kRpcDoubletRMin;
}
int rpcDoubletZ(int mfid ) {
  return ((mfid >> kRpcDoubletZShift) & kRpcDoubletZMask) + kRpcDoubletZMin;
}
int rpcDoubletPhi(int mfid) {
  return ((mfid >> kRpcDoubletPhiShift) & kRpcDoubletPhiMask) + kRpcDoubletPhiMin;
}
int rpcGasGap(int mfid) {
   return ((mfid >> kRpcGasGapShift) & kRpcGasGapMask) + kRpcGasGapMin;
}
int rpcMeasuresPhi(int mfid) {
  return ((mfid >> kRpcMeasuresPhiShift) & kRpcMeasuresPhiMask) + kRpcMeasuresPhiMin;
}
int rpcStrip(int mfid) {
  return ((mfid >> kRpcStripShift) & kRpcStripMask) + kRpcStripMin;
}

int setRpcDoubletR( int num, int mfid ) {
  num -=  kRpcDoubletRMin;
  if( num > kRpcDoubletRMask ) {
    cout << "Error setRpcDoubletR bad number =" << num << endl; 
    return mfid;
  }
  mfid &= ~( kRpcDoubletRMask <<  kRpcDoubletRShift );
  mfid |= (num &  kRpcDoubletRMask) << kRpcDoubletRShift;
  return mfid;
}

int setRpcDoubletZ( int num, int mfid ) {
  num -=  kRpcDoubletZMin;
  if ( num > kRpcDoubletZMask ) {
    cout << "Error setRpcDoubletZ bad number =" << num << endl; 
    return mfid;
  }
  mfid &= ~( kRpcDoubletZMask <<  kRpcDoubletZShift );
  mfid |= (num &  kRpcDoubletZMask) << kRpcDoubletZShift;
  return mfid;
}

int setRpcDoubletPhi( int num, int mfid ) {
  num -= kRpcDoubletPhiMin;
  if ( num > kRpcDoubletPhiMask ) {
    cout << "Error setRpcDoubletPhi bad number =" << num << endl; 
    return mfid;
  }
  mfid &= ~( kRpcDoubletPhiMask <<  kRpcDoubletPhiShift );
  mfid |= (num &  kRpcDoubletPhiMask) << kRpcDoubletPhiShift;
  return mfid;
}

int setRpcGasGap( int num, int mfid ) {
  num -= kRpcGasGapMin;
  if ( num > kRpcGasGapMask ) {
    cout << "Error setRpcGasGap bad number =" << num << endl; 
    return mfid;
  }
  mfid &= ~( kRpcGasGapMask <<  kRpcGasGapShift );
  mfid |= (num &  kRpcGasGapMask) << kRpcGasGapShift;
  return mfid;
}

int setRpcMeasuresPhi( int num, int mfid ) {
  num -= kRpcMeasuresPhiMin;
  if ( num > kRpcMeasuresPhiMask ) {
    cout << "Error setRpcGasGap bad number =" << num << endl; 
    return mfid;
  }
  mfid &= ~( kRpcMeasuresPhiMask <<  kRpcMeasuresPhiShift );
  mfid |= (num &  kRpcMeasuresPhiMask) << kRpcMeasuresPhiShift;
  return mfid;
}

int setRpcStrip( int num, int mfid ) {
  num -= kRpcStripMin;
  if ( num > kRpcStripMask ) {
    cout << "Error setRpcStrip bad number =" << num << endl; 
    return mfid;
  }
  mfid &= ~( kRpcStripMask <<  kRpcStripShift );
  mfid |= (num &  kRpcStripMask) << kRpcStripShift;
  return mfid;
}

/*****************************************************************
*  TGC routines
******************************************************************/
//  Writes the full TGC chamber name for a given MuonFixedID
void TgcName(int mfid, char *cname) {
  char cend, ctype[4];  
  int sid = StationID(mfid);
  sprintf(ctype,"%s",ChamberType(sid));
  int is   = tgcIsStrip(mfid);
  int ig   = tgcGasGap(mfid);
  int ic   = tgcChannel(mfid);
  int iphi = StationPhi(mfid);
  int ieta = StationEta(mfid);
  sprintf(cname,"%s%i%2.2i-%i-%i-%i",ctype,ieta,iphi,is,ig,ic);
  return;
}
//  Writes the TGC chamber name for a given MuonFixedID
void TgcChamber(int mfid, char *cname) {
  char cend, ctype[4];  
  int sid = StationID(mfid);
  sprintf(ctype,"%s",ChamberType(sid));
  int iphi = StationPhi(mfid);
  int ieta = StationEta(mfid);
  sprintf(cname,"%s%i%2.2i",ctype,ieta,iphi);
  return;
}

int tgcGasGap(int mfid) {
  return ((mfid >> kTgcGasGapShift) & kTgcGasGapMask) + kTgcGasGapMin;
}
int tgcIsStrip(int mfid) {
  return ((mfid >> kTgcIsStripShift) & kTgcIsStripMask) + kTgcIsStripMin;
}
int tgcChannel(int mfid) {
  return ((mfid >> kTgcChannelShift) & kTgcChannelMask) + kTgcChannelMin;
}

int setTgcGasGap( int num, int mfid ) {
  num -= kTgcGasGapMin;
  if ( num > kTgcGasGapMask ) {
    cout << "Error setTgcGasGap bad number =" << num << endl; 
    return mfid;
  }
  mfid &= ~( kTgcGasGapMask <<  kTgcGasGapShift );
  mfid |= (num &  kTgcGasGapMask) << kTgcGasGapShift;
  return mfid;
}

int setTgcIsStrip( int num, int mfid ) {
  num -= kTgcIsStripMin;
  if ( num > kTgcIsStripMask ) {
    cout << "Error setTgcIsStrip bad number =" << num << endl; 
    return mfid;
  }
  mfid &= ~( kTgcIsStripMask <<  kTgcIsStripShift );
  mfid |= (num &  kTgcIsStripMask) << kTgcIsStripShift;
  return mfid;
}

int setTgcChannel( int num, int mfid ) {
  num -= kTgcChannelMin;
  if ( num > kTgcChannelMask ) {
    cout << "Error setTgcChannel bad number =" << num << endl; 
    return mfid;
  }
  mfid &= ~( kTgcChannelMask <<  kTgcChannelShift );
  mfid |= (num &  kTgcChannelMask) << kTgcChannelShift;
  return mfid;
}

/*****************************************************************
*  CSC routines
******************************************************************/
//  Writes the CSC chamber name for a given MuonFixedID
void CscName(int mfid, char *cname) {
  char cend, ctype[4];  
  int sid = StationID(mfid);
  sprintf(ctype,"%s",ChamberType(sid));
  int il   = cscChamberLayer(mfid);
  int iw   = cscWireLayer(mfid);
  int is   = cscStrip(mfid);
  int iphi = StationPhi(mfid);
  int ieta = StationEta(mfid);
  sprintf(cname,"%s%i%2.2i-%i-%i-%i",ctype,ieta,iphi,il,iw,is);
  return;
}
int cscChamberLayer(int mfid) {
  return ((mfid >> kCscChamberLayerShift) & kCscChamberLayerMask) + kCscChamberLayerMin;
}
int cscWireLayer(int mfid) {
  return ((mfid >> kCscWireLayerShift) & kCscWireLayerMask) + kCscWireLayerMin;
}
int cscMeasuresPhi(int mfid) {
  return ((mfid >> kCscMeasuresPhiShift) & kCscMeasuresPhiMask) + kCscMeasuresPhiMin;
}
int cscStrip(int mfid) {
  return ((mfid >> kCscStripShift) & kCscStripMask) + kCscStripMin;
}

int setCscChamberLayer( int num, int mfid ) {
  num -= kCscChamberLayerMin;
  if ( num > kCscChamberLayerMask ) {
    cout << "Error setCscChamberLayer bad number =" << num << endl; 
    return mfid;
  }
  mfid &= ~( kCscChamberLayerMask <<  kCscChamberLayerShift );
  mfid |= (num &  kCscChamberLayerMask) << kCscChamberLayerShift;
  return mfid;
}

int setCscWireLayer( int num, int mfid ) {
  num -= kCscWireLayerMin;
  if ( num > kCscWireLayerMask ) {
    cout << "Error setCscWireLayer bad number =" << num << endl; 
    return mfid;
  }
  mfid &= ~( kCscWireLayerMask <<  kCscWireLayerShift );
  mfid |= (num &  kCscWireLayerMask) << kCscWireLayerShift;
  return mfid;
}

int setCscMeasuresPhi( int num, int mfid ) {
  num -= kCscMeasuresPhiMin;
  if ( num > kCscMeasuresPhiMask ) {
    cout << "Error setCscMeasuresPhi bad number =" << num << endl; 
    return mfid;
  }
  mfid &= ~( kCscMeasuresPhiMask <<  kCscMeasuresPhiShift );
  mfid |= (num &  kCscMeasuresPhiMask) << kCscMeasuresPhiShift;
  return mfid;
}

int setCscStrip( int num, int mfid ) {
  num -= kCscStripMin;
  if ( num > kCscStripMask ) {
    cout << "Error setCscStrip bad number =" << num << endl; 
    return mfid;
  }
  mfid &= ~( kCscStripMask <<  kCscStripShift );
  mfid |= (num &  kCscStripMask) << kCscStripShift;
  return mfid;
}