Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010 #include "CalibMuon/DTCalibration/plugins/DTCalibrationMap.h"
00011
00012 #include "FWCore/Utilities/interface/Exception.h"
00013 #include "FWCore/ParameterSet/interface/ParameterSet.h"
00014
00015 #include <iostream>
00016 #include <fstream>
00017
00018 #include <sstream>
00019 #include <algorithm>
00020 #include <iterator>
00021
00022 using namespace std;
00023 using namespace edm;
00024
00025 DTCalibrationMap::DTCalibrationMap(const ParameterSet& pset) {
00026 nFields = pset.getUntrackedParameter<int>("nFields", 5);
00027 calibConstFileName = pset.getUntrackedParameter<string>("calibConstFileName", "dummy.txt");
00028 calibConstGranularity = pset.getUntrackedParameter<string>("calibConstGranularity","bySL");
00029
00030
00031 if(calibConstGranularity == "byWire") {
00032 theGranularity = byWire;
00033 } else if(calibConstGranularity == "byLayer"){
00034 theGranularity = byLayer;
00035 } else if(calibConstGranularity == "bySL") {
00036 theGranularity = bySL;
00037 } else {
00038 theGranularity = byChamber;
00039 if(!(calibConstGranularity == "byChamber")) {
00040 cout << "[DTCalibrationMap]###Warning: Check parameter calibConstGranularity: "
00041 << calibConstGranularity << " options not available!" << endl;
00042 }
00043 }
00044 readConsts(calibConstFileName);
00045 }
00046
00047
00048
00049 DTCalibrationMap::~DTCalibrationMap(){}
00050
00051
00052
00053
00054 float DTCalibrationMap::tTrig(DTWireId wireId) const {
00055 return getField(wireId, 0);
00056 }
00057
00058
00059
00060
00061 float DTCalibrationMap::sigma_tTrig(DTWireId wireId) const {
00062 return getField(wireId, 1);
00063 }
00064
00065
00066
00067
00068 float DTCalibrationMap::kFactor(DTWireId wireId) const {
00069 return getField(wireId, 2);
00070 }
00071
00072
00073
00074
00075 float DTCalibrationMap::meanVDrift(DTWireId wireId) const {
00076 return getField(wireId, 3);
00077 }
00078
00079
00080
00081
00082 float DTCalibrationMap::sigma_meanVDrift(DTWireId wireId) const {
00083 return getField(wireId, 4);
00084 }
00085
00086
00087
00088
00089
00090 DTCalibrationMap::Key DTCalibrationMap::getKey(DTWireId wireId) const {
00091 if (theGranularity == byChamber){
00092 return Key(wireId.chamberId(), 0, 0, 0);
00093 } else if (theGranularity == bySL) {
00094 return Key(wireId.superlayerId(), 0, 0);
00095 } else if (theGranularity == byLayer) {
00096 return Key(wireId.layerId(), 0);
00097 } else {
00098 return Key(wireId);
00099 }
00100 }
00101
00102
00103
00104
00105 const DTCalibrationMap::CalibConsts* DTCalibrationMap::getConsts(DTWireId wireId) const {
00106
00107 static pair<Key, CalibConsts> cache;
00108
00109
00110 Key theKey = getKey(wireId);
00111
00112
00113 if ( theKey == cache.first ) {
00114 return &(cache.second);
00115 }
00116
00117
00118 map<Key, CalibConsts>::const_iterator res = theMap.find(theKey);
00119 if (res != theMap.end()) {
00120 cache = (*res);
00121 return &((*res).second);
00122 } else {
00123 return 0;
00124 }
00125 }
00126
00127
00128
00129
00130
00131 float DTCalibrationMap::getField(DTWireId wireId, int field) const {
00132 const CalibConsts* cals = getConsts(wireId);
00133 if (cals == 0) {
00134 throw cms::Exception("NoCalibConsts") << "DTCalibrationMap:" << endl
00135 << "No parameters for wire: " << wireId << endl
00136 << "Check the " << calibConstFileName << " file!" << endl;
00137 } else {
00138 return (*(cals))[field];
00139 }
00140 }
00141
00142
00143
00144
00145
00146 void DTCalibrationMap::readConsts(const string& inputFileName) {
00147 ifstream file(inputFileName.c_str());
00148
00149 if(!file) {
00150 cout << "[DTCalibrationMap]***Warning: File: " << inputFileName
00151 << " not found in current directory!!!" << endl;
00152 }
00153
00154 string line;
00155
00156
00157 int wheel_id = 0;
00158 int station_id = 0;
00159 int sector_id = 0;
00160 int superlayer_id = 0;
00161 int layer_id = 0;
00162 int wire_id = 0;
00163
00164
00165 while (getline(file,line)) {
00166 if( line == "" || line[0] == '#' ) continue;
00167 stringstream linestr;
00168 linestr << line;
00169
00170 pair<Key, CalibConsts> wireCalib;
00171
00172 linestr >> wheel_id
00173 >> station_id
00174 >> sector_id
00175 >> superlayer_id
00176 >> layer_id
00177 >> wire_id;
00178
00179
00180 wireCalib.first = Key( wheel_id,
00181 station_id,
00182 sector_id,
00183 superlayer_id,
00184 layer_id,
00185 wire_id);
00186
00187 if(!checkGranularity(wireCalib.first))
00188 cout << "[DTCalibrationMap]***Warning: the CalibConstFile is not consistent with the selected granularity!" << endl;
00189
00190
00191
00192 copy(istream_iterator<float>(linestr),
00193 istream_iterator<float>(),
00194 back_inserter(wireCalib.second));
00195
00196 if(wireCalib.second.size() != nFields){
00197 cout << "[DTCalibrationMap]***Warning: the CalibConstFile is not consistent with the number of fields!" << endl;
00198 }
00199
00200 theMap.insert(wireCalib);
00201 }
00202 }
00203
00204
00205 void DTCalibrationMap::addCell(Key theKey, const CalibConsts& calibConst) {
00206 if(!checkGranularity(theKey))
00207 throw cms::Exception("addCell") << "DTCalibrationMap:" << endl
00208 << "The added key is not compatible with the selected granularity"
00209 << endl;
00210
00211 theMap[theKey] = calibConst;
00212 }
00213
00214
00215 void DTCalibrationMap::writeConsts(const string& outputFileName) const {
00216 ofstream out(outputFileName.c_str());
00217 for(map<Key,CalibConsts>::const_iterator iter = theMap.begin();
00218 iter != theMap.end() ; iter++) {
00219
00220 out << (*iter).first.wheel() << ' '
00221 << (*iter).first.station() << ' '
00222 << (*iter).first.sector() << ' '
00223 << (*iter).first.superlayer() << ' '
00224 << (*iter).first.layer() << ' '
00225 << (*iter).first.wire() << ' ';
00226 copy((*iter).second.begin(), (*iter).second.end(),
00227 ostream_iterator<float>(out, " "));
00228 out << endl;
00229 }
00230 }
00231
00232
00233
00234 bool DTCalibrationMap::checkGranularity(Key aKey) const {
00235 bool ret = true;
00236
00237
00238 if(theGranularity == byChamber) {
00239 if(aKey.superlayer() || aKey.layer() || aKey.wire()) {
00240 ret = false;
00241 }
00242 } else if(theGranularity == bySL) {
00243 if(aKey.layer() || aKey.wire()) {
00244 ret = false;
00245 }
00246 } else if(theGranularity == byLayer) {
00247 if(aKey.wire()) {
00248 ret = false;
00249 }
00250 } else if(theGranularity == byWire) {
00251 if(aKey.wire() == 0) {
00252 ret = false;
00253 }
00254 }
00255 return ret;
00256 }