RPCSimSetUp Class Reference

#include <RPCSimSetUp.h>

Public Member Functions
const std::vector< double > &	getAsymmetricClsDistribution (uint32_t id, uint32_t slice)
const std::vector< double > &	getAsymmetryForCls (uint32_t id, uint32_t slice, uint32_t cls)
const std::vector< double > &	getCls (uint32_t id)
const std::map< int, std::vector< double > > &	getClsMap ()
const std::vector< float > &	getEff (uint32_t id)
const RPCGeometry *	getGeometry ()
const std::vector< float > &	getNoise (uint32_t id)
float	getTime (uint32_t id)
	RPCSimSetUp (const edm::ParameterSet &ps)
void	setGeometry (const RPCGeometry *geom)
	sets geometry More...
void	setRPCSetUp (const std::vector< RPCStripNoises::NoiseItem > &vnoise, const std::vector< float > &vcls)
void	setRPCSetUp (const std::vector< RPCStripNoises::NoiseItem > &vnoise, const std::vector< RPCClusterSize::ClusterSizeItem > &vClusterSize)
virtual	~RPCSimSetUp ()

Public Attributes
std::map< RPCDetId, float >	_bxmap
std::map< int, std::vector < double > >	_clsMap
std::vector< double >	_DetAsymmetryForCls
std::vector< double >	_DetClsAsymmetric
std::map< uint32_t, std::vector< double > >	_mapDetClsMap
std::map< uint32_t, std::vector< double > >	_mapDetClsMapLegacy
std::map< uint32_t, std::vector< float > >	_mapDetIdEff
std::map< uint32_t, std::vector< float > >	_mapDetIdNoise
const RPCGeometry *	theGeometry

Detailed Description

Definition at line 28 of file RPCSimSetUp.h.

Constructor & Destructor Documentation

RPCSimSetUp::RPCSimSetUp ( const edm::ParameterSet &  ps )

explicit

Definition at line 37 of file RPCSimSetUp.cc.

                                                  {

  _mapDetIdNoise.clear();
  _mapDetIdEff.clear();
  _bxmap.clear();
  _clsMap.clear();
}

RPCSimSetUp::~RPCSimSetUp ( )

virtual

Definition at line 559 of file RPCSimSetUp.cc.

{}

Member Function Documentation

const std::vector< double > & RPCSimSetUp::getAsymmetricClsDistribution	(	uint32_t	id,
		uint32_t	slice
	)

Definition at line 426 of file RPCSimSetUp.cc.

References counter, Exception, i, j, and LogDebug.

Referenced by RPCSimAsymmetricCls::getClSize().

                                                                                              {

  LogDebug ("RPCSimSetupChecks")<<"RPCSimSetUp::getAsymmetricClsDistribution"<<std::endl;

  map<uint32_t,std::vector<double> >::const_iterator iter = _mapDetClsMap.find(id);
  if(iter == _mapDetClsMap.end()){
    throw cms::Exception("DataCorrupt")
      << "Exception from RPCSimSetUp - _mapDetClsMap - no cluster size information for DetId\t"<<id<< std::endl;
  }
  if((iter->second).size() != 120){
    throw cms::Exception("DataCorrupt")
      << "Exception from RPCSimSetUp - _mapDetClsMap - cluster size information in a wrong format for DetId\t"<<id<< std::endl;
  }
  //  return iter->second;

  std::vector<double> dataForAsymmCls = iter->second;
  if(slice>4){ 
    throw cms::Exception("DataCorrupt") 
      << "Exception from RPCSimSetUp - slice variable not in the range"<< std::endl;
  }     

  _DetClsAsymmetric.clear();
   

  vector<double> clsFewStripsDistribution;
  vector<double> clsDistribution;
  vector<double> clsAccumulativeDistribution;
  
  std::map< int, std::vector<double> > mapSliceVsDistribution;

  const int slices=5;
  const int distributionFewStrips=24;

  double sliceVsFewStripsDistribution[slices][distributionFewStrips];
    
  for(int j = 0; j < distributionFewStrips; j++){
    for(int i = 0; i < slices; i++){
      sliceVsFewStripsDistribution[i][j]=dataForAsymmCls[j*slices+i];
    }
  }

double control=0;
for(int j = 0 ; j < distributionFewStrips; j++){
control+=sliceVsFewStripsDistribution[0][j];
} 

double control1=0;
  for(int j = 0; j < distributionFewStrips; j++){
    for(int i = 0; i < slices; i++){
      control1+=dataForAsymmCls[j*slices+i];
    }
  }

  int i = slice;
  double sum=0;
  int counter = 0 ;
  for(int j = 0; j < distributionFewStrips; j++){
    counter++;
    sum+=sliceVsFewStripsDistribution[i][j];
    if(counter%4==0){
      _DetClsAsymmetric.push_back(sum);
    }
  }
  return _DetClsAsymmetric;
}

const std::vector< double > & RPCSimSetUp::getAsymmetryForCls	(	uint32_t	id,
		uint32_t	slice,
		uint32_t	cls
	)

Definition at line 492 of file RPCSimSetUp.cc.

References Exception, i, j, LogDebug, findQualityFiles::size, and relativeConstraints::value.

Referenced by RPCSimAsymmetricCls::simulate().

                                                                                                  {

  LogDebug ("RPCSimSetupChecks")<<"RPCSimSetUp::getAsymmetryForCls"<<std::endl;

 map<uint32_t,std::vector<double> >::const_iterator iter = _mapDetClsMap.find(id);
  if(iter == _mapDetClsMap.end()){
    throw cms::Exception("DataCorrupt")
      << "Exception from RPCSimSetUp - _mapDetClsMap - no cluster size information for DetId\t"<<id<< std::endl;
  }
  if((iter->second).size() != 120){
    throw cms::Exception("DataCorrupt")
      << "Exception from RPCSimSetUp - _mapDetClsMap - cluster size information in a wrong format for DetId\t"<<id<<'\t'<<(iter->second).size()<< std::endl;
  }

std::vector<double> dataForAsymmCls = iter->second;

if(slice>4){ 
     throw cms::Exception("DataCorrupt") 
       << "Exception from RPCSimSetUp - slice variable not in the range"<< std::endl;
   }   

  _DetAsymmetryForCls.clear();

 vector<double> clsFewStripsDistribution;
  vector<double> clsDistribution;
  vector<double> clsAccumulativeDistribution;
vector<double> clsDetAsymmetryForCls;
 clsDetAsymmetryForCls.clear();
  
  std::map< int, std::vector<double> > mapSliceVsDistribution;

  const int slices=5;
  const int distributionFewStrips=24;

  double sliceVsFewStripsDistribution[slices][distributionFewStrips];
    
  for(int j = 0; j < distributionFewStrips; j++){
    for(int i = 0; i < slices; i++){
      sliceVsFewStripsDistribution[i][j]=dataForAsymmCls[j*slices+i];
    }
  }

  int vector_lenght;
  switch(cls){
  case 1:  case 3:  case 5:   vector_lenght =3; break;
  case 2:  case 4:            vector_lenght =4; break;
  case 6:  default:           vector_lenght = 1; break;
  }
  
  float sum=0;
  float value;
  for(int i = 0; i < vector_lenght ; i ++){
    value = sliceVsFewStripsDistribution[slice][(cls-1)*4+i];
    clsDetAsymmetryForCls.push_back(value);
    sum +=value; 
    //     LogDebug ("RPCSimSetup")<<"value\t"<<value<<std::endl;
    //    LogDebug ("RPCSimSetup")<<"sum\t"<<sum<<std::endl;
  }
  
  float accum=0;
  for(int i = clsDetAsymmetryForCls.size()-1; i>-1; i--){
    accum += clsDetAsymmetryForCls[i];
    _DetAsymmetryForCls.push_back(accum/sum);
  }
return  _DetAsymmetryForCls;
}

const std::vector< double > & RPCSimSetUp::getCls

(

uint32_t

id

)

Definition at line 408 of file RPCSimSetUp.cc.

References Exception, and LogDebug.

Referenced by RPCSimAverageNoiseEffCls::getClSize().

{

  LogDebug ("RPCSimSetupChecks")<<"RPCSimSetUp::getCls"<<std::endl;

  map<uint32_t,std::vector<double> >::iterator iter = _mapDetClsMapLegacy.find(id);
  if(iter == _mapDetClsMapLegacy.end()){
    throw cms::Exception("DataCorrupt") 
      << "Exception from RPCSimSetUp - no cluster size information for DetId\t"<<id<< std::endl;
  }
  if((iter->second).size() != 100){
    throw cms::Exception("DataCorrupt") 
      << "Exception from RPCSimSetUp - _mapDetClsMapLegacy - cluster size information in a wrong format for DetId\t"<<id<< std::endl;
  }
  LogDebug ("RPCSimSetupChecks")<< "All OK from RPCSimSetUp - _mapDetClsMapLegacy - cluster size information for DetId\t"<<id<< std::endl;
  return iter->second;
}

const std::map< int, std::vector< double > > & RPCSimSetUp::getClsMap

(

)

Definition at line 397 of file RPCSimSetUp.cc.

References Exception.

Referenced by RPCSimAverage::getClSize(), RPCSimAverageNoise::getClSize(), RPCSimAverageNoiseEff::getClSize(), RPCSimAverageNoiseEffCls::getClSize(), and RPCSimAsymmetricCls::getClSize().

{
  if(_clsMap.size()!=5){
    throw cms::Exception("DataCorrupt") 
      << "Exception from RPCSimSetUp - cluster size - a wrong format "<< std::endl;
  }
  return _clsMap;
}

const std::vector< float > & RPCSimSetUp::getEff

(

uint32_t

id

)

Definition at line 364 of file RPCSimSetUp.cc.

References Exception, LogDebug, RPCRoll::nstrips(), RPCDetId, and findQualityFiles::size.

{
  map<uint32_t,std::vector<float> >::iterator iter = _mapDetIdEff.find(id);
  if(iter == _mapDetIdEff.end()){
    throw cms::Exception("DataCorrupt") 
      << "Exception from RPCSimSetUp - no efficiency information for DetId\t"<<id<< std::endl;
  }

  RPCDetId rpcId = RPCDetId(id);
  const RPCRoll* roll = theGeometry->roll(rpcId);
  unsigned int numbStrips = roll->nstrips();

  if((iter->second).size() < numbStrips){
    LogDebug ("RPCSimSetup")<< "Exception from RPCSimSetUp - efficiency information in a wrong format for DetId\t"<<id<<" aka "<<RPCDetId(id)<<std::endl;
    LogDebug ("RPCSimSetup")<<" number of strips in Conditions\t"<<(iter->second).size()<<" number of strips in Geometry\t"<<numbStrips<<std::endl;
    throw cms::Exception("DataCorrupt")
      << "Exception from RPCSimSetUp - efficiency information in a wrong format for DetId\t"<<id<< std::endl;
  }

  return iter->second;
}

const RPCGeometry* RPCSimSetUp::getGeometry ( )

inline

Definition at line 50 of file RPCSimSetUp.h.

References theGeometry.

Referenced by RPCSynchronizer::getSimHitBx().

{ return theGeometry; }

const std::vector< float > & RPCSimSetUp::getNoise

(

uint32_t

id

)

Definition at line 353 of file RPCSimSetUp.cc.

References Exception, and LogDebug.

{
  map<uint32_t,std::vector<float> >::iterator iter = _mapDetIdNoise.find(id);
  if(iter == _mapDetIdNoise.end()){
    throw cms::Exception("DataCorrupt") 
      << "Exception from RPCSimSetUp - no noise information for DetId\t"<<id<< std::endl;
  }
  LogDebug ("RPCSimSetupChecks")<< "All OK from RPCSimSetUp - noise information for DetId\t"<<id<< std::endl;
  return iter->second;
}

float RPCSimSetUp::getTime

(

uint32_t

id

)

Definition at line 386 of file RPCSimSetUp.cc.

References Exception, and DetId::rawId().

Referenced by RPCSynchronizer::getSimHitBx().

{
  RPCDetId rpcid(id);
  std::map<RPCDetId, float>::iterator iter = _bxmap.find(rpcid);
  if(iter == _bxmap.end()){
    throw cms::Exception("DataCorrupt") 
      << "Exception from RPCSimSetUp - no timing information for rpcid.rawId()\t"<<rpcid.rawId()<< std::endl;
  }
  return iter->second;
}

void RPCSimSetUp::setGeometry ( const RPCGeometry *  geom )

inline

sets geometry

Definition at line 48 of file RPCSimSetUp.h.

References relativeConstraints::geom, and theGeometry.

Referenced by RPCDigiProducer::beginRun().

{theGeometry = geom;}

void RPCSimSetUp::setRPCSetUp	(	const std::vector< RPCStripNoises::NoiseItem > &	vnoise,
		const std::vector< float > &	vcls
	)

Definition at line 45 of file RPCSimSetUp.cc.

References counter, gen::n, RPCDetId, and groupFilesInBlocks::temp.

Referenced by RPCDigiProducer::beginRun().

                                                                                                           {

  unsigned int counter = 1;
  unsigned int row = 1;
  std::vector<double> sum_clsize;

  for(unsigned int n = 0; n < vcls.size(); ++n){

    sum_clsize.push_back(vcls[n]);

    if(counter == row*20) {

      _clsMap[row] = sum_clsize;
      row++;
      sum_clsize.clear();
    }
    counter++;
  }

  unsigned int n = 0; 
  uint32_t temp = 0; 
  std::vector<float> veff, vvnoise;
  veff.clear();
  vvnoise.clear();

  for(std::vector<RPCStripNoises::NoiseItem>::const_iterator it = vnoise.begin(); it != vnoise.end(); ++it){
    if(n%96 == 0) {
      if(n > 0 ){
    _mapDetIdNoise[temp]= vvnoise;
    _mapDetIdEff[temp] = veff;
    _bxmap[RPCDetId(it->dpid)] = it->time;
    
    veff.clear();
    vvnoise.clear();
    vvnoise.push_back((it->noise));
    veff.push_back((it->eff));
      }
      else if(n == 0 ){
    vvnoise.push_back((it->noise));
    veff.push_back((it->eff));
    _bxmap[RPCDetId(it->dpid)] = it->time;
      }
    } else if (n == vnoise.size()-1 ){
      temp = it->dpid;
      vvnoise.push_back((it->noise));
      veff.push_back((it->eff));
      _mapDetIdNoise[temp]= vvnoise;
      _mapDetIdEff[temp] = veff;
    } else {
      temp = it->dpid;
      vvnoise.push_back((it->noise));
      veff.push_back((it->eff));
    }
    n++;
  }
}

void RPCSimSetUp::setRPCSetUp	(	const std::vector< RPCStripNoises::NoiseItem > &	vnoise,
		const std::vector< RPCClusterSize::ClusterSizeItem > &	vClusterSize
	)

Definition at line 102 of file RPCSimSetUp.cc.

References LogDebug, RPCRoll::nstrips(), RPCDetId, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                                                           {

  LogDebug ("RPCSimSetup")<<"RPCSimSetUp::setRPCSetUp(vector<NoiseItem>, vector<ClusterSizeItem>)"<<std::endl;

  uint32_t detId, current_detId, this_detId;
  RPCDetId rpcId, current_rpcId, this_rpcId;
  const RPCRoll * current_roll = nullptr;
  const RPCRoll * this_roll = nullptr;
  unsigned int current_nStrips;

  LogDebug ("RPCSimSetup")<<"RPCSimSetUp::setRPCSetUp :: ClusterSizeItem :: begin"<<std::endl;
  std::stringstream sslogclsitem;
  // ### ClusterSizeItem #######################################################                        
  std::vector<RPCClusterSize::ClusterSizeItem>::const_iterator itCls;
  int clsCounter(1);
  std::vector<double> clsVect;
  // ### loop for New Format (120 entries)
  for(itCls = vClusterSize.begin(); itCls != vClusterSize.end(); ++itCls){
    sslogclsitem<<" Push back clustersize = "<<itCls->clusterSize<<std::endl;
    clsVect.push_back(((double)(itCls->clusterSize)));
    sslogclsitem<<"Filling cls in _mapDetCls[detId,clsVect] :: detId = "<<detId;
    sslogclsitem<<" --> will it be accepted? clsCounter = "<<clsCounter<<" accepted?";
    sslogclsitem<<" New Format ::"<<((!(clsCounter%120)) && (clsCounter!=0)); // <<std::endl;
    sslogclsitem<<" Old Format ::"<<((!(clsCounter%100)) && (clsCounter!=0)); // <<std::endl;
    sslogclsitem<<std::endl;

    // New Format :: loop until 120
    if((!(clsCounter%120)) && (clsCounter!=0)){
      detId=itCls->dpid;
      _mapDetClsMap[detId]=clsVect;
      std::stringstream LogDebugClsVectString;
      LogDebugClsVectString<<"[";
      for(std::vector<double>::iterator itClsVect = clsVect.begin(); itClsVect != clsVect.end(); ++itClsVect) {
        LogDebugClsVectString<<*itClsVect<<",";
      }
      LogDebugClsVectString<<"]";
      std::string LogDebugClsVectStr = LogDebugClsVectString.str();
      LogDebug ("RPCSimSetup")<<"Filling clsVect in _mapDetCls[detId,clsVect] :: detId = "<<RPCDetId(detId)<<" = "<<detId<<" clsVec = "<<LogDebugClsVectStr;

      sslogclsitem<<" --> New Method ";
      sslogclsitem<<" --> saved in map "<<std::endl;
      sslogclsitem<<"Filling cls in _mapDetClsMap[detId,clsVect] :: detId = "<<detId;
      sslogclsitem<<" --> will it be accepted? clsCounter = "<<clsCounter<<" accepted? "<<((!(clsCounter%120)) && (clsCounter!=0))<<std::endl;
      clsVect.clear();
      clsCounter=0;
    }
    else{
      sslogclsitem<<" --> not saved in map "<<std::endl;
    }
    ++clsCounter;
  }
  // ### loop for Old Format (100 entries)
  for(itCls = vClusterSize.begin(); itCls != vClusterSize.end(); ++itCls){
    sslogclsitem<<" Push back clustersize = "<<itCls->clusterSize<<std::endl;
    clsVect.push_back(((double)(itCls->clusterSize)));
    sslogclsitem<<"Filling cls in _mapDetClsMapLegacy[detId,clsVect] :: detId = "<<detId;
    sslogclsitem<<" --> will it be accepted? clsCounter = "<<clsCounter<<" accepted?";
    sslogclsitem<<" New Format ::"<<((!(clsCounter%120)) && (clsCounter!=0)); // <<std::endl;
    sslogclsitem<<" Old Format ::"<<((!(clsCounter%100)) && (clsCounter!=0)); // <<std::endl;
    sslogclsitem<<std::endl;

    // Old Format :: same until 100
    if((!(clsCounter%100)) && (clsCounter!=0)){
      detId=itCls->dpid;
      _mapDetClsMapLegacy[detId]=clsVect;
      std::stringstream LogDebugClsVectString;
      LogDebugClsVectString<<"[";
      for(std::vector<double>::iterator itClsVect = clsVect.begin(); itClsVect != clsVect.end(); ++itClsVect) {
        LogDebugClsVectString<<*itClsVect<<",";
      }
      LogDebugClsVectString<<"]";
      std::string LogDebugClsVectStr = LogDebugClsVectString.str();
      LogDebug ("RPCSimSetup")<<"Filling clsVect in _mapDetClsLegacy[detId,clsVect] :: detId = "<<RPCDetId(detId)<<" = "<<detId<<" clsVec = "<<LogDebugClsVectStr;

      sslogclsitem<<" --> Old Method ";
      sslogclsitem<<" --> saved in map "<<std::endl;
      sslogclsitem<<"Filling cls in _mapDetClsMapLegacy[detId,clsVect] :: detId = "<<detId;
      sslogclsitem<<" --> will it be accepted? clsCounter = "<<clsCounter<<" accepted? "<<((!(clsCounter%120)) && (clsCounter!=0))<<std::endl;
      clsVect.clear();
      clsCounter=0;
    }
    else{
      sslogclsitem<<" --> not saved in map "<<std::endl;
    }
    ++clsCounter;
  }
  // ###########################################################################
  std::string logclsitem = sslogclsitem.str(); sslogclsitem.clear();
  LogDebug ("RPCSimSetupClsLoopDetails")<<logclsitem<<std::endl;
  LogDebug ("RPCSimSetup")<<"RPCSimSetUp::setRPCSetUp :: ClusterSizeItem :: end"<<std::endl;

  LogDebug ("RPCSimSetup")<<"RPCSimSetUp::setRPCSetUp :: NoiseItem :: begin"<<std::endl;
  std::stringstream sslognoiseitem;
  // ### NoiseItem #############################################################
  unsigned int count_strips = 1;
  unsigned int count_all    = 1;
  std::vector<float> vveff, vvnoise;

  // DetId to start with needs to be a DetId inside the Geometry used
  // Therefore loop on the NoiseItems and search for the first valid roll in the Geometry
  // Assign this as the DetId to start with (so called current_roll) and quit the loop
  bool quitLoop = false;
  current_detId = 0; current_nStrips = 0; // current_rpcId = 0; current_roll = 0;
  for(std::vector<RPCStripNoises::NoiseItem>::const_iterator it = vnoise.begin(); it != vnoise.end() && !quitLoop; ++it) {
    // roll associated to the conditions of this strip (iterator)
    current_detId = it->dpid;
    current_rpcId = RPCDetId(current_detId);
    // Test whether this roll (picked up from the conditions) is inside the RPC Geometry
    const RPCRoll* roll = theGeometry->roll(current_rpcId);
    if(roll==0) {
      sslognoiseitem <<"Searching for first valid detid :: current_detId = "<<current_detId;
      sslognoiseitem <<" aka "<<current_rpcId<<" is not in current Geometry --> Skip "<<std::endl;
      continue;
    }
    else {
      sslognoiseitem <<"Searching for first valid detid :: current_detId = "<<current_detId;
      sslognoiseitem <<" aka "<<current_rpcId<<" is the first (valid) roll in the current Geometry --> Accept, Assign & Quit Loop"<<std::endl;
      current_roll    = theGeometry->roll(current_rpcId);
      current_nStrips = current_roll->nstrips();
      quitLoop = true;
    }
  }

  sslognoiseitem <<"Start Position ::            current_detId = "<<current_detId<<" aka "<<current_rpcId;
  sslognoiseitem <<" is a valid roll with pointer "<<current_roll<<" and has "<<(current_roll?current_roll->nstrips():0)<<" strips"<<std::endl;
  sslognoiseitem <<" ------------------------------------------------------------------------------------------------------------------------------------- "<<std::endl;
  for(std::vector<RPCStripNoises::NoiseItem>::const_iterator it = vnoise.begin(); it != vnoise.end(); ++it) {

    // roll associated to the conditions of this strip (iterator)
    this_detId = it->dpid;
    this_rpcId = RPCDetId(this_detId);
    // Test whether this roll (picked up from the conditions) is inside the RPC Geometry
    const RPCRoll* roll = theGeometry->roll(this_rpcId);
    if(roll==0) {
      sslognoiseitem <<"Inside Loop :: ["<<std::setw(6)<<count_all<<"]["<<std::setw(3)<<count_strips<<"] :: this_detId = "<<this_detId<<" aka "<<this_rpcId<<" which is not in current Geometry --> Skip "<<std::endl;
      continue;
    }

    // Case 1 :: FIRST ENTRY
    // ---------------------
    if(this_detId == current_detId && count_strips == 1) {
      sslognoiseitem<<"RPCSimSetUp::setRPCSetUp :: NoiseItem :: case 1"<<std::endl;
      sslognoiseitem<<this_detId<<" = "<<this_rpcId<<" with "<<roll->nstrips()<<" strips"<<std::endl;
      // fill bx in map
      _bxmap[current_detId] = it->time;
      sslognoiseitem<<"[NoiseItem :: n = "<<count_all<<"] Filling time in _bxmap[detId] :: detId = "<<RPCDetId(it->dpid)<<" time = "<<it->time<<std::endl;
      // clear vectors
      vveff.clear();
      vvnoise.clear();
      // fill the vectors
      vvnoise.push_back((it->noise));
      vveff.push_back((it->eff));
      sslognoiseitem <<"First Value :: ["<<std::setw(6)<<count_all<<"]["<<std::setw(3)<<count_strips<<"] :: this_detId = "<<this_detId<<" aka "<<this_rpcId;
      sslognoiseitem <<" Strip "<<std::setw(3)<<count_strips<<" Noise = "<<it->noise<<" Hz/cm2"<<std::endl;
      // update counter
      ++count_strips;
      ++count_all;
    }
    // Case 2 :: 2ND ENTRY --> LAST-1 ENTRY
    // ------------------------------------
    else if(this_detId == current_detId && count_strips > 1 && count_strips < current_nStrips) {
      sslognoiseitem<<"RPCSimSetUp::setRPCSetUp :: NoiseItem :: case 2"<<std::endl;
      sslognoiseitem <<"Inside Loop :: ["<<std::setw(6)<<count_all<<"]["<<std::setw(3)<<count_strips<<"] :: this_detId = "<<this_detId<<" aka "<<this_rpcId;
      sslognoiseitem <<" Strip "<<std::setw(3)<<count_strips<<" Noise = "<<it->noise<<" Hz/cm2"<<std::endl;
      // fill the vectors
      vvnoise.push_back((it->noise));
      vveff.push_back((it->eff));
      // update counter
      ++count_strips;
      ++count_all;
    }

    // Case 3 :: LAST ENTRY
    // --------------------
    else if(this_detId == current_detId && count_strips == current_nStrips) {
      sslognoiseitem<<"RPCSimSetUp::setRPCSetUp :: NoiseItem :: case 3"<<std::endl;
      // fill last value in the vector
      sslognoiseitem <<"Last Value ::  ["<<std::setw(6)<<count_all<<"]["<<std::setw(3)<<count_strips<<"] :: this_detId = "<<this_detId<<" aka "<<this_rpcId;
      sslognoiseitem <<" Strip "<<std::setw(3)<<count_strips<<" Noise = "<<it->noise<<" Hz/cm2"<<std::endl;
      vvnoise.push_back((it->noise));
      vveff.push_back((it->eff));
      // update counter
      ++count_strips;
      ++count_all;
      // fill vectors into map
      sslognoiseitem <<" fill vectors into map"<<std::endl;
      _mapDetIdNoise[current_detId]= vvnoise;
      _mapDetIdEff[current_detId] = vveff;

      std::stringstream LogDebugNoiVectString, LogDebugEffVectString;
      LogDebugNoiVectString<<"[";
      for(std::vector<float>::iterator itNoiVect = vvnoise.begin(); itNoiVect != vvnoise.end(); ++itNoiVect) {
        LogDebugNoiVectString<<(*itNoiVect)<<",";
      }
      LogDebugNoiVectString<<"]";
      std::string LogDebugNoiVectStr = LogDebugNoiVectString.str();
      LogDebugEffVectString<<"[";
      for(std::vector<float>::iterator itEffVect = vveff.begin(); itEffVect != vveff.end(); ++itEffVect) {
        LogDebugEffVectString<<(*itEffVect)<<",";
      }
      LogDebugEffVectString<<"]";
      std::string LogDebugEffVectStr = LogDebugEffVectString.str();
      LogDebug ("RPCSimSetup")<<"Filling vvnoise in _mapDetIdNoise[detId] :: detId = "<<RPCDetId(it->dpid)<<" = "<<(RPCDetId(it->dpid)).rawId()<<" vvnoise = "<<LogDebugNoiVectStr;
      LogDebug ("RPCSimSetup")<<"Filling veff    in _mapDetIdEff[detId]   :: detId = "<<RPCDetId(it->dpid)<<" = "<<(RPCDetId(it->dpid)).rawId()<<" veff    = "<<LogDebugEffVectStr;

      // look for next different detId and rename it to the current_detId
      // at this point we skip all the conditions for the strips that are not in this roll
      // and we will go to the conditions for the first strip of the next roll
      bool next_detId_found = 0;
      sslognoiseitem <<"look for next different detId"<<std::endl;
      while(next_detId_found==0 && it != vnoise.end()-1) {
        ++it;
        this_detId = it->dpid;
        this_rpcId = RPCDetId(this_detId);
        this_roll = theGeometry->roll(this_rpcId);
        if(!this_roll) continue;
        sslognoiseitem <<"Inside While:: ["<<std::setw(6)<<count_all<<"]["<<std::setw(3)<<count_strips<<"] :: this_detId = "<<this_detId<<" aka "<<this_rpcId<<" Noise = "<<it->noise<<" Hz/cm2"<<std::endl;
        ++count_strips;
        // ++count_all;                                                                      
        if(this_detId != current_detId) {
          sslognoiseitem <<"Different detId is found ::                  "<<this_detId<<" aka "<<this_rpcId<<" Noise = "<<it->noise<<" Hz/cm2";
          // next roll is found. update current_detId to this newly found detId
          // and update also the number of strips
          current_detId = this_detId;
          current_rpcId = RPCDetId(current_detId);
          next_detId_found = 1;
          current_nStrips = (theGeometry->roll(current_rpcId))->nstrips();
          sslognoiseitem <<" with "<<current_nStrips<<" strips"<<std::endl;
          --it; // subtract one, because at the end of the loop the iterator will be increased with one
      // in fact the treatment for roll N stops when we find the first occurence of roll N+1
      // however we want to start the treatment for roll N+1 with the first occurence of roll N+1
      // so the first entry of each new roll N+1 is manipulated twice in the loop (once as a stop, once as a start)
      // therefore we have to manipulate the iterator here, subtracting one, to treat again this entry
        }
      }
      // reset count_strips
      count_strips = 1;
    }
    // There should be no Case 4
    // -------------------------
    else {}
  }
  // ###########################################################################
  std::string lognoiseitem = sslognoiseitem.str(); sslognoiseitem.clear();
  LogDebug ("RPCSimSetupNoiseLoopDetails")<<lognoiseitem<<std::endl;
  LogDebug ("RPCSimSetup")<<"RPCSimSetUp::setRPCSetUp :: NoiseItem :: end"<<std::endl;

  LogDebug ("RPCSimSetup")<<"RPCSimSetUp::setRPCSetUp :: end"<<std::endl;
}

Member Data Documentation

std::map<RPCDetId, float> RPCSimSetUp::_bxmap

Definition at line 56 of file RPCSimSetUp.h.

std::map< int, std::vector<double> > RPCSimSetUp::_clsMap

Definition at line 57 of file RPCSimSetUp.h.

std::vector<double> RPCSimSetUp::_DetAsymmetryForCls

Definition at line 61 of file RPCSimSetUp.h.

std::vector<double> RPCSimSetUp::_DetClsAsymmetric

Definition at line 60 of file RPCSimSetUp.h.

std::map<uint32_t, std::vector<double> > RPCSimSetUp::_mapDetClsMap

Definition at line 58 of file RPCSimSetUp.h.

std::map<uint32_t, std::vector<double> > RPCSimSetUp::_mapDetClsMapLegacy

Definition at line 59 of file RPCSimSetUp.h.

std::map<uint32_t, std::vector<float> > RPCSimSetUp::_mapDetIdEff

Definition at line 55 of file RPCSimSetUp.h.

std::map<uint32_t, std::vector<float> > RPCSimSetUp::_mapDetIdNoise

Definition at line 54 of file RPCSimSetUp.h.

const RPCGeometry* RPCSimSetUp::theGeometry

Definition at line 52 of file RPCSimSetUp.h.

Referenced by getGeometry(), and setGeometry().