00001 #include "GaudiKernel/Algorithm.h"
00002 #include "MdcGeomSvc/MdcGeomSvc.h"
00003 #include "GaudiKernel/Kernel.h"
00004 #include "GaudiKernel/IIncidentSvc.h"
00005 #include "GaudiKernel/Incident.h"
00006 #include "GaudiKernel/IIncidentListener.h"
00007 #include "GaudiKernel/IInterface.h"
00008 #include "GaudiKernel/StatusCode.h"
00009 #include "GaudiKernel/SvcFactory.h"
00010 #include "GaudiKernel/PropertyMgr.h"
00011 #include "GaudiKernel/SmartDataPtr.h"
00012 #include "CalibData/CalibModel.h"
00013 #include "CalibData/Mdc/MdcAlignData.h"
00014 #include "GaudiKernel/MsgStream.h"
00015 #include "EventModel/EventHeader.h"
00016 #include "EventModel/Event.h"
00017 #include "GaudiKernel/ISvcLocator.h"
00018 #include "GaudiKernel/IDataProviderSvc.h"
00019 #include "GaudiKernel/Bootstrap.h"
00020 #include <fstream>
00021 #include <float.h>
00022
00023
00024
00025
00026 bool MdcGeomSvc::m_doSag = true;
00027 bool MdcGeomSvc::m_readAlignParDataBase = true;
00028 bool MdcGeomSvc::m_nomcalignment=true;
00029
00030 MdcGeomSvc::MdcGeomSvc( const std::string& name, ISvcLocator* svcloc ) : Service(name, svcloc) {
00031 if(getenv("MDCGEOMSVCROOT")){
00032 m_alignFilePath = std::string(getenv("MDCGEOMSVCROOT"))+std::string("/share/MdcAlignPar.dat");
00033
00034
00035 m_wirePosFilePath = std::string(getenv("MDCGEOMSVCROOT"))+std::string("/share/WirePosCalib.dat");
00036
00037
00038 m_wireTensionFilePath = std::string(getenv("MDCGEOMSVCROOT"))+std::string("/share/mdcWireTension.dat");
00039
00040
00041 }
00042 else {
00043 std::cout<<"A fatal error, contact wangjk..."<<std::endl;
00044 }
00045
00046 declareProperty("doSag", m_doSag = true);
00047 declareProperty("readAlignParDataBase", m_readAlignParDataBase = true);
00048 declareProperty("mcnoalignment",m_nomcalignment=true);
00049 declareProperty("wholeShiftX",m_wholeShiftX = 0.);
00050 declareProperty("wholeShiftY",m_wholeShiftY = 0.);
00051 declareProperty("wholeShiftZ",m_wholeShiftZ = 0.);
00052 declareProperty("wholeRotatX",m_wholeRotatX = 0.);
00053 declareProperty("wholeRotatY",m_wholeRotatY = 0.);
00054 declareProperty("wholeRotatZ",m_wholeRotatZ = 0.);
00055 declareProperty("alignFilePath",m_alignFilePath);
00056 declareProperty("wirePosFilePath",m_wirePosFilePath);
00057 declareProperty("wireTensionFilePath",m_wireTensionFilePath);
00058
00059
00060 }
00061
00062 StatusCode MdcGeomSvc::queryInterface (const InterfaceID& riid, void** ppvInterface ){
00063
00064 if ( IID_IMdcGeomSvc.versionMatch(riid) ) {
00065 *ppvInterface = static_cast<IMdcGeomSvc*> (this);
00066 } else {
00067 return Service::queryInterface(riid, ppvInterface) ;
00068 }
00069 return StatusCode::SUCCESS;
00070 }
00071
00072 StatusCode MdcGeomSvc::initialize ( ) {
00073 MsgStream log(messageService(), name());
00074 log << MSG::INFO << name() << ": Start of run initialisation" << endreq;
00075
00076 StatusCode sc = Service::initialize();
00077 if ( sc.isFailure() ) return sc;
00078 m_mindex=0;
00079 m_updataalign = false;
00080 IIncidentSvc* incsvc;
00081 sc = service("IncidentSvc", incsvc);
00082 int priority = 100;
00083 if( sc.isSuccess() ){
00084 incsvc -> addListener(this, "NewRun", priority);
00085 }
00086
00087
00088
00089
00090 sc = service("CalibDataSvc", m_pCalibDataSvc, true);
00091
00092 if ( !sc.isSuccess() ) {
00093 log << MSG::ERROR
00094 << "Could not get IDataProviderSvc interface of CalibXmlCnvSvc"
00095 << endreq;
00096 return sc;
00097 } else {
00098 log << MSG::DEBUG
00099 << "Retrieved IDataProviderSvc interface of CalibXmlCnvSvc"
00100 << endreq;
00101 }
00102 ReadFilePar();
00103 return StatusCode::SUCCESS;
00104 }
00105
00106 StatusCode MdcGeomSvc::finalize ( ) {
00107 MsgStream log(messageService(), name());
00108 log << MSG::INFO << name() << ": End of Run" << endreq;
00109 return StatusCode::SUCCESS;
00110 }
00111
00112 MdcGeomSvc::~MdcGeomSvc(){
00113 for(vector<MdcGeoLayer*>::iterator it1 = fLayers.begin(); it1 != fLayers.end(); it1++) delete *it1;
00114 for(vector<MdcGeoSuper*>::iterator it2 = fSupers.begin(); it2 != fSupers.end(); it2++) delete *it2;
00115 for(vector<MdcGeoWire*>::iterator it3 = fWires.begin(); it3 != fWires.end(); it3++) delete *it3;
00116 for(vector<MdcGeoEnd*>::iterator it4 = fEnd.begin(); it4 != fEnd.end(); it4++) delete *it4;
00117 fGenerals.clear();
00118 fWires.clear();
00119 fLayers.clear();
00120 fSupers.clear();
00121 fEnd.clear();
00122 }
00123
00124 void MdcGeomSvc::clean(){
00125 for(vector<MdcGeoLayer*>::iterator it1 = fLayers.begin(); it1 != fLayers.end(); it1++) delete *it1;
00126 for(vector<MdcGeoSuper*>::iterator it2 = fSupers.begin(); it2 != fSupers.end(); it2++) delete *it2;
00127 for(vector<MdcGeoWire*>::iterator it3 = fWires.begin(); it3 != fWires.end(); it3++) delete *it3;
00128 for(vector<MdcGeoEnd*>::iterator it4 = fEnd.begin(); it4 != fEnd.end(); it4++) delete *it4;
00129 fGenerals.clear();
00130 fWires.clear();
00131 fLayers.clear();
00132 fSupers.clear();
00133 fEnd.clear();
00134 }
00135
00136
00137 void MdcGeomSvc::ReadFilePar(){
00138 std::string geometryFilePath = getenv("MDCSIMROOT");
00139 geometryFilePath += "/dat/Mdc.txt";
00140 std::ifstream inFile(geometryFilePath.c_str() );
00141
00142 if(!inFile.good()){
00143 std::cout<<"Error, mdc parameters file not exist"<<std::endl;
00144 return;
00145 }
00146 std::string alignFilePath;
00147 std::string wirePosFilePath;
00148 std::string wireTensionFilePath;
00149 if (!m_updataalign) {
00150 alignFilePath = std::string(getenv("MDCGEOMSVCROOT"))+std::string("/share/MdcAlignPar.dat");
00151 wirePosFilePath = std::string(getenv("MDCGEOMSVCROOT"))+std::string("/share/WirePosCalib.dat");
00152 wireTensionFilePath = std::string(getenv("MDCGEOMSVCROOT"))+std::string("/share/mdcWireTension.dat");
00153 } else {
00154 alignFilePath = m_alignFilePath;
00155 wirePosFilePath = m_wirePosFilePath;
00156 wireTensionFilePath = m_wireTensionFilePath;
00157 }
00158 std::ifstream alignFile(alignFilePath.c_str());
00159 std::ifstream wirePosFile(wirePosFilePath.c_str());
00160 std::ifstream wireTensionFile(wireTensionFilePath.c_str());
00161
00162 if(!wirePosFile){
00163 std::cout<<"Error, mdc wire position file not exist..."<<std::endl;
00164 }
00165
00166 if(!wireTensionFile){
00167 std::cout<<"Error, mdc wire tension file not exist..."<<std::endl;
00168 }
00169
00170 std::vector<double> wireTensionVec;
00171
00172
00173 if (m_readAlignParDataBase && m_updataalign) {
00174 ReadTensionDataBase(wireTensionVec);
00175 }else {
00176 cout << "Read wireTension from file:" << wireTensionFilePath.c_str() << endl;
00177 int idd;
00178 double tension;
00179 for(int ii=0; ii<6796; ii++){
00180 wireTensionFile>>idd>>tension;
00181
00182 if(getSagFlag()){
00183 wireTensionVec.push_back(tension);
00184 }
00185 else {
00186 tension = DBL_MAX;
00187 wireTensionVec.push_back(tension);
00188 }
00189 }
00190 }
00191
00192 std::vector<vector<double> > wirePosVec(6796);
00193 if (m_readAlignParDataBase && m_updataalign) {
00194 ReadWirePosDataBase(wirePosVec);
00195 } else {
00196 cout << "Read wirePosition from file:" << wirePosFilePath.c_str() << endl;
00197 double dxe,dye,dze,dxw,dyw,dzw;
00198 int wid;
00199 std::string title;
00200 getline(wirePosFile, title);
00201 wirePosFile.seekg(1,ios::cur);
00202 for(int j=0; j<6796; j++){
00203 wirePosFile>>wid>>dxe>>dye>>dze>>dxw>>dyw>>dzw;
00204 wirePosVec[j].push_back(dxe);
00205 wirePosVec[j].push_back(dye);
00206 wirePosVec[j].push_back(dze);
00207 wirePosVec[j].push_back(dxw);
00208 wirePosVec[j].push_back(dyw);
00209 wirePosVec[j].push_back(dzw);
00211
00212
00213
00214
00215
00216 }
00217 }
00218
00219 double signalWireR, fieldWireR;
00220 int TLayerNo, TWireNo,TSignalLayerNo,fSignalLayer[50];
00221 int i,wireNo, firstWire,segmentNo,signalLayer;
00222 double length, nomphi, phi, r,nomaadiv2, aadiv2,
00223 nomaa, aa, nomrotateCell, rotateCell, wlength, innerR, outR, z;
00224 std::string layer, name, line;
00225
00226 vector<int> WireNo, fSegmentNo;
00227 vector<double> wLength, R, nomPhi, Phi,nomadiv2, adiv2, First,
00228 noma, a, nomebusing, ebusing, nomsigma, sigma, nomdeltaz, deltaz,
00229 nomRotate, Rotate, fLength, fInnerR, fOutR, fZ;
00230 vector<string> LayerName, fName;
00231 vector<double> Sx,Sy,Sz,Rx,Ry,Rz;
00232 double tmp1,tmp2,tmp3,tmp4,tmp5,tmp6;
00233
00235
00236 if (m_readAlignParDataBase && m_updataalign) {
00237 ReadAliParDataBase(Sx, Sy, Sz, Rx, Ry, Rz);
00238 } else {
00239 cout << "Read alignment parameters from file:" << alignFilePath.c_str() << endl;
00240 getline(alignFile, line);
00241 alignFile.seekg(1,ios::cur);
00242 for(int k=0;k<16;k++){
00243 alignFile>>line>>tmp1>>tmp2>>tmp3>>tmp4>>tmp5>>tmp6;
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253 Sx.push_back(m_wholeShiftX+tmp1);
00254 Sy.push_back(m_wholeShiftY+tmp2);
00255 Sz.push_back(m_wholeShiftZ+tmp3);
00256 Rx.push_back(m_wholeRotatX+tmp4);
00257 Ry.push_back(m_wholeRotatY+tmp5);
00258 Rz.push_back(m_wholeRotatZ+tmp6);
00259 }
00262 }
00263
00264 getline(inFile, line);
00265 inFile>>TLayerNo>>TWireNo>>TSignalLayerNo>>signalWireR>>fieldWireR;
00266 inFile.seekg(1,ios::cur);
00267 getline(inFile, line);
00268 for( i=0; i<TSignalLayerNo; i++){
00269 inFile>>signalLayer;
00271 fSignalLayer[i]=signalLayer-1;
00272 }
00273
00274 inFile.seekg(1,ios::cur);
00275 getline(inFile, line);
00276 getline(inFile, line);
00277
00278 int i_east,i_west;
00279 double delta_rotateCell;
00281 for( i=0; i<TLayerNo; i++){
00282 i_east=getAlignParIndexEast(i);
00283 i_west=getAlignParIndexWest(i);
00284
00285 inFile>>layer>>wireNo>>wlength>>r>>nomphi>>firstWire>>nomrotateCell;
00286 getline(inFile, line);
00287
00290 nomaadiv2=2*pi*nomrotateCell/wireNo;
00291
00292 nomaa=2*r*sin(nomaadiv2);
00293 delta_rotateCell=(Rz[i_west]-Rz[i_east])*wireNo/(4*pi);
00294 rotateCell=nomrotateCell+delta_rotateCell;
00295 aadiv2=2*pi*rotateCell/wireNo;
00296 aa=2*r*sin(aadiv2);
00297
00298 double shiftPhi=twopi/wireNo;
00299 nomphi*=deg;
00300 if(nomphi<0) nomphi += shiftPhi;
00301 phi=nomphi+Rz[i_east];
00302 LayerName.push_back(layer);
00303 WireNo.push_back(wireNo);
00304 wLength.push_back(wlength);
00305 R.push_back(r);
00306 nomPhi.push_back(nomphi);
00307 Phi.push_back(phi);
00308
00309
00310 First.push_back(firstWire);
00311
00312 a.push_back(aa);
00317
00318 nomebusing.push_back(atan(nomaa/wlength));
00319 ebusing.push_back(atan(aa/wlength));
00320
00321
00322
00323
00324
00325 nomRotate.push_back(nomrotateCell);
00326 Rotate.push_back(rotateCell);
00327 }
00328
00329 getline(inFile, line);
00330 inFile>>segmentNo;
00331 inFile.seekg(1,ios::cur);
00332 getline(inFile, line);
00333 getline(inFile, line);
00334
00335 for(i=0; i<segmentNo; i++){
00336 inFile>>length>>innerR>>outR>>z>>name;
00337 getline(inFile,line);
00338 fLength.push_back(length);
00339 fInnerR.push_back(innerR);
00340 fOutR.push_back(outR);
00341 fZ.push_back(z);
00342 fName.push_back(name);
00343 }
00344
00351
00352
00353 MdcGeoGeneral hlh;
00354 double a1,a2,a3,nomphi0,phi0,cellphi;
00355 double noma1,noma2,noma3;
00356 for(i=0;i<TLayerNo;i++){
00357 i_east=getAlignParIndexEast(i);
00358 i_west=getAlignParIndexWest(i);
00359 hlh.Id(i);
00360 hlh.LayerName(LayerName[i]);
00361 hlh.Radius(R[i]);
00362 hlh.Length(wLength[i]);
00363 hlh.NCell(WireNo[i]/2);
00364
00365
00366 hlh.Offset(Phi[i]);
00367 hlh.nomOffset(nomPhi[i]);
00368 hlh.Phi(Phi[i]);
00369 hlh.nomPhi(nomPhi[i]);
00370 hlh.First((int)First[i]);
00371 HepPoint3D offF(Sx[i_west],Sy[i_west],Sz[i_west]);
00372 HepPoint3D offB(Sx[i_east],Sy[i_east],Sz[i_east]);
00373 hlh.OffF(offF);
00374 hlh.OffB(offB);
00375 hlh.TwistF(Rz[i_west]);
00376 hlh.TwistB(Rz[i_east]);
00377
00378
00379 hlh.Shift(Rotate[i]);
00380 hlh.nomShift(nomRotate[i]);
00381 hlh.SxEast(Sx[i_east]);
00382 hlh.SxWest(Sx[i_west]);
00383 hlh.SyEast(Sy[i_east]);
00384 hlh.SyWest(Sy[i_west]);
00385 hlh.SzEast(Sz[i_east]);
00386 hlh.SzWest(Sz[i_west]);
00387
00388 hlh.RxEast(Rx[i_east]);
00389 hlh.RxWest(Rx[i_west]);
00390 hlh.RyEast(Ry[i_east]);
00391 hlh.RyWest(Ry[i_west]);
00392 hlh.RzEast(Rz[i_east]);
00393 hlh.RzWest(Rz[i_west]);
00394 fGenerals.push_back(hlh);
00395 }
00396
00397 MdcGeoSuper *suph;
00398 for(i=0;i<TSignalLayerNo;i++){
00399
00400 MdcGeoLayer *lh = new MdcGeoLayer();
00401
00402 int lyr=fSignalLayer[i];
00403
00404
00405 i_east=getAlignParIndexEast(lyr);
00406 i_west=getAlignParIndexWest(lyr);
00407 lh->SLayer(lyr+1);
00408 if(i%4==0){
00409 suph = new MdcGeoSuper();
00410 suph->LowerR(R[lyr-1]);
00411 if(i==40){
00412 suph->UpperR(R[lyr+5]);
00413 }
00414 else {
00415 suph->UpperR(R[lyr+7]);
00416 }
00417 switch(i/4){
00418 case 0: suph->Type(-1); break;
00419 case 1: suph->Type( 1); break;
00420 case 2: suph->Type( 0); break;
00421 case 3: suph->Type( 0); break;
00422 case 4: suph->Type( 0); break;
00423 case 5: suph->Type(-1); break;
00424 case 6: suph->Type( 1); break;
00425 case 7: suph->Type(-1); break;
00426 case 8: suph->Type( 1); break;
00427 case 9: suph->Type( 0); break;
00428 case 10: suph->Type(0); break;
00429 default: break;
00430 }
00431 suph->Id(i/4);
00432 fSupers.push_back(suph);
00433 }
00435 cellphi=2*twopi/WireNo[lyr];
00437 phi0=Phi[lyr]+abs(First[lyr]-1)*(cellphi/2);
00438 nomphi0=nomPhi[lyr]+abs(First[lyr]-1)*(cellphi/2);
00439 lh->Id(i);
00440 int wircount=0;
00441 for(int wk=0; wk<i; wk++){
00442 int lyrwk=fSignalLayer[wk];
00443 wircount=wircount + WireNo[lyrwk]/2;
00444 };
00447 lh->Wirst(wircount);
00448 lh->Slant(ebusing[lyr]);
00449 lh->nomSlant(nomebusing[lyr]);
00450 lh->Radius(R[lyr]);
00451 lh->Length(wLength[lyr]);
00452 lh->RCSiz1(R[lyr]-R[lyr-1]);
00453 lh->RCSiz2(R[lyr+1]-R[lyr]);
00454 lh->PCSiz(R[lyr]*cellphi);
00455 lh->NCell(WireNo[lyr]/2);
00456 lh->Offset(phi0);
00457 lh->Shift(Rotate[lyr]);
00458 lh->nomOffset(nomphi0);
00459 lh->nomShift(nomRotate[lyr]);
00460
00461 vector<MdcGeoSuper*>::iterator it1 = fSupers.end()-1;
00462 lh->Sup(* it1);
00463 fLayers.push_back(lh);
00464 int geo = -1;
00465 if (i < 8) {
00466 geo = i * 2 + 1;
00467 } else if (i < 20) {
00468 geo = i * 2 + 2;
00469 } else if (i < 36) {
00470 geo = i * 2 + 3;
00471 } else {
00472 geo = i * 2 + 4;
00473 }
00474 lh->Gen(geo);
00475
00476 for(int j=0;j<WireNo[lyr]/2;j++){
00478 MdcGeoWire *wh = new MdcGeoWire();
00479 const int wireId = wircount+j;
00480 wh->Id(wireId);
00481
00483 a1 = R[lyr]*cos(phi0+j*cellphi)+Sx[i_east]+wirePosVec[wireId][0];
00484 a2 = R[lyr]*sin(phi0+j*cellphi)+Sy[i_east]+wirePosVec[wireId][1];
00485 a3 = wLength[lyr]/2+wirePosVec[wireId][2]+Sz[i_east];
00486
00487
00488 double xb = a1;
00489 double yb = a2 * cos(Rx[i_east]) + a3 * sin(Rx[i_east]);
00490 double zb = a3 * cos(Rx[i_east]) - a2 * sin(Rx[i_east]);
00491
00492
00493 double xbnew = xb * cos(Ry[i_east]) - zb * sin(Ry[i_east]);
00494 double ybnew = yb;
00495 double zbnew = xb * sin(Ry[i_east]) + zb * cos(Ry[i_east]);
00497 noma1 = R[lyr]*cos(nomphi0+j*cellphi);
00498 noma2 = R[lyr]*sin(nomphi0+j*cellphi);
00500 noma3 = wLength[lyr]/2;
00501
00502 HepPoint3D pb(xbnew,ybnew,zbnew);
00503 HepPoint3D nompb(noma1,noma2,noma3);
00504 HepPoint3D wireposb(wirePosVec[wireId][0],wirePosVec[wireId][1],wirePosVec[wireId][2]);
00505 wh->Backward(pb);
00506 wh->nomBackward(nompb);
00507 wh->BWirePos(wireposb);
00508
00509
00510
00511
00512
00513
00514 a1 = R[lyr]*cos(phi0+(j+lh->Shift())*cellphi)+Sx[i_west]+wirePosVec[wireId][3];
00515 a2 = R[lyr]*sin(phi0+(j+lh->Shift())*cellphi)+Sy[i_west]+wirePosVec[wireId][4];
00516
00517 a3 = -wLength[lyr]/2+wirePosVec[wireId][5]+Sz[i_west];
00518
00519 double xf = a1;
00520 double yf = a2 * cos(Rx[i_west]) + a3 * sin(Rx[i_west]);
00521 double zf = a3 * cos(Rx[i_west]) - a2 * sin(Rx[i_west]);
00522
00523
00524 double xfnew = xf * cos(Ry[i_west]) - zf * sin(Ry[i_west]);
00525 double yfnew = yf;
00526 double zfnew = xf * sin(Ry[i_west]) + zf * cos(Ry[i_west]);
00527
00528 noma1 = R[lyr]*cos(nomphi0+(j+lh->nomShift())*cellphi);
00529 noma2 = R[lyr]*sin(nomphi0+(j+lh->nomShift())*cellphi);
00530 noma3 = -wLength[lyr]/2;
00531
00532 HepPoint3D pf(xfnew, yfnew, zfnew);
00533 HepPoint3D nompf(noma1,noma2,noma3);
00534 HepPoint3D wireposf(wirePosVec[wireId][3],wirePosVec[wireId][4],wirePosVec[wireId][5]);
00535 wh->Forward(pf);
00536 wh->nomForward(nompf);
00537 wh->FWirePos(wireposf);
00538
00539
00540
00541
00542
00545 wh->Layer(i);
00546 wh->Cell(j);
00547 wh->Stat(0);
00548 wh->Slant(ebusing[lyr]);
00549 wh->nomSlant(nomebusing[lyr]);
00550
00552 wh->Tension(wireTensionVec[wireId]);
00553
00554
00555
00559 vector<MdcGeoLayer*>::iterator it2 = fLayers.end()-1;
00560 wh->Lyr(* it2);
00561 fWires.push_back(wh);
00562 }
00563 }
00564
00565 fMisc.OuterR(fOutR[1]);
00566 fMisc.InnerR(fInnerR[2]);
00567 fMisc.OuterTk(fOutR[1]-fInnerR[1]);
00568 fMisc.InnerTk(fOutR[2]-fInnerR[2]);
00569 fMisc.NSWire(fWires.size());
00570 fMisc.NFWire(TWireNo-fWires.size());
00571
00572 fMisc.LayerNo(TLayerNo);
00573 fMisc.WireNo(TWireNo);
00574 fMisc.SLayerNo(TSignalLayerNo);
00575 fMisc.SWireR(signalWireR);
00576 fMisc.FWireR(fieldWireR);
00577
00578 for(i=0;i<segmentNo;i++){
00579 MdcGeoEnd * end=new MdcGeoEnd();
00580 end->Id(i);
00581 end->Length(fLength[i]);
00582 end->InnerR(fInnerR[i]);
00583 end->OutR(fOutR[i]);
00584 end->Z(fZ[i]);
00585 end->Name(fName[i]);
00586 fEnd.push_back(end);
00587 }
00588 }
00589
00590 void MdcGeomSvc::ReadTensionDataBase(std::vector<double> & wireTensionVec){
00591 std::string fullPath = "/Calib/MdcAlign";
00592 MsgStream log(messageService(), name());
00593 log << MSG::INFO<<"ReadTensionDataBase() wireTensionPath = "<<fullPath<< endreq;
00594 cout << "Read wireTension from Calibration Database!" << endl;
00595
00596 SmartDataPtr<CalibData::MdcAlignData> tension(m_pCalibDataSvc, fullPath);
00597 if( ! tension){
00598 log << MSG::ERROR << "can not get MdcAlignConst via SmartPtr"
00599 << endreq;
00600 return;
00601 }
00602 for(int i=0;i<6796;i++){
00603 double tens = tension->gettension(i);
00604 wireTensionVec.push_back(tens);
00605 }
00606 }
00607 void MdcGeomSvc::ReadWirePosDataBase(std::vector<vector<double> > & wirePosVec){
00608 std::string fullPath = "/Calib/MdcAlign";
00609 MsgStream log(messageService(), name());
00610 log << MSG::INFO<<"ReadWirePosDataBase() wirePositionPath = "<<fullPath<< endreq;
00611
00612 cout << "Read wirePosition from Calibration Database!" << endl;
00613 SmartDataPtr<CalibData::MdcAlignData> wirepos(m_pCalibDataSvc, fullPath);
00614 if( ! wirepos){
00615 log << MSG::ERROR << "can not get MdcAlignConst via SmartPtr"
00616 << endreq;
00617 return;
00618 }
00619 double dxe,dye,dze,dxw,dyw,dzw;
00620 for(int j=0; j<6796; j++){
00621
00622 dxe = wirepos->getdxWireEast(j);
00623 dye = wirepos->getdyWireEast(j);
00624 dze = wirepos->getdzWireEast(j);
00625 dxw = wirepos->getdxWireWest(j);
00626 dyw = wirepos->getdyWireWest(j);
00627 dzw = wirepos->getdzWireWest(j);
00628
00629 wirePosVec[j].push_back(dxe);
00630 wirePosVec[j].push_back(dye);
00631 wirePosVec[j].push_back(dze);
00632 wirePosVec[j].push_back(dxw);
00633 wirePosVec[j].push_back(dyw);
00634 wirePosVec[j].push_back(dzw);
00635 }
00636
00637 }
00638 void MdcGeomSvc::ReadAliParDataBase(vector<double>& Sx, vector<double>& Sy, vector<double>& Sz,
00639 vector<double>& Rx, vector<double>& Ry, vector<double>& Rz){
00640 MsgStream log(messageService(), name());
00641 std::string fullPath = "/Calib/MdcAlign";
00642 log << MSG::INFO<<"ReadAliParDataBase() alignParPath = "<<fullPath<< endreq;
00643 cout << "Read alignment parameters from Calibration Database!" << endl;
00644
00645 SmartDataPtr<CalibData::MdcAlignData> alignpar(m_pCalibDataSvc, fullPath);
00646 if( ! alignpar){
00647 log << MSG::ERROR << "can not get MdcAlignConst via SmartPtr"
00648 << endreq;
00649 return;
00650 }
00651 double tmp1,tmp2,tmp3,tmp4,tmp5,tmp6;
00652 for(int k=0;k<16;k++){
00653 tmp1 = alignpar->getdxEP(k);
00654 tmp2 = alignpar->getdyEP(k);
00655 tmp3 = alignpar->getdzEP(k);
00656 tmp4 = alignpar->getrxEP(k);
00657 tmp5 = alignpar->getryEP(k);
00658 tmp6 = alignpar->getrzEP(k);
00659
00660 Sx.push_back(m_wholeShiftX+tmp1);
00661 Sy.push_back(m_wholeShiftY+tmp2);
00662 Sz.push_back(m_wholeShiftZ+tmp3);
00663 Rx.push_back(m_wholeRotatX+tmp4);
00664 Ry.push_back(m_wholeRotatY+tmp5);
00665 Rz.push_back(m_wholeRotatZ+tmp6);
00666 }
00667
00668 }
00669 const int MdcGeomSvc::getWireSize()
00670 {
00671 return fWires.size();
00672 }
00673
00674 const int MdcGeomSvc::getLayerSize()
00675 {
00676 return fLayers.size();
00677 }
00678
00679 const int MdcGeomSvc::getSuperLayerSize()
00680 {
00681 return fSupers.size();
00682 }
00683
00684 const int MdcGeomSvc::getGeneralLayerSize()
00685 {
00686 return fGenerals.size();
00687 }
00688
00689 const int MdcGeomSvc::getSegmentNo()
00690 {
00691 return fEnd.size();
00692 }
00693
00694 void MdcGeomSvc::Dump(){}
00695
00696 const int MdcGeomSvc::getAlignParIndexEast(int lyr) const{
00698 if((lyr>=0) && (lyr<=16)) return 0;
00700 else if((lyr>=17) && (lyr<=20)) return 1;
00702 else if((lyr>=21) && (lyr<=24)) return 2;
00704 else if((lyr>=25) && (lyr<=28)) return 3;
00706 else if((lyr>=29) && (lyr<=32)) return 4;
00708 else if((lyr>=33) && (lyr<=36)) return 5;
00710 else if((lyr>=37) && (lyr<=41)) return 6;
00712 else if(lyr>=42) return 7;
00713 else std::cout<<" Hi, ERROR OCCUR !!!"<<std::endl;
00714 return -1;
00715 }
00716
00717
00718 const int MdcGeomSvc::getAlignParIndexWest(int lyr) const{
00720 if((lyr>=0) && (lyr<=16)) return 8;
00722 else if((lyr>=17) && (lyr<=20)) return 9;
00724 else if((lyr>=21) && (lyr<=24)) return 10;
00726 else if((lyr>=25) && (lyr<=28)) return 11;
00728 else if((lyr>=29) && (lyr<=32)) return 12;
00730 else if((lyr>=33) && (lyr<=36)) return 13;
00732 else if((lyr>=37) && (lyr<=41)) return 14;
00734 else if(lyr>=42) return 15;
00735 else std::cout<<" Hi, ERROR OCCUR !!!"<<std::endl;
00736 return -1;
00737 }
00738
00739
00741 void MdcGeomSvc::handle(const Incident& inc){
00742 MsgStream log( messageService(), name() );
00743 log << MSG::DEBUG << "handle: " << inc.type() << endreq;
00744 IDataProviderSvc* m_eventSvc;
00745 Gaudi::svcLocator()->service("EventDataSvc", m_eventSvc, true);
00746 SmartDataPtr<Event::EventHeader> eventHeader(m_eventSvc,"/Event/EventHeader");
00747 if (!eventHeader) {
00748 log << MSG::FATAL << "Could not find Event Header" << endreq;
00749 }
00750 if (m_updataalign) return;
00751 if (inc.type() == "NewRun" ){
00752 log << MSG::DEBUG << "Begin Event" << endreq;
00753 clean();
00754 m_updataalign = true;
00755 if(m_nomcalignment&&m_mindex==0) {
00756 int RunNo=eventHeader->runNumber();
00757 if(RunNo<0) m_readAlignParDataBase=false ;
00758 else m_readAlignParDataBase=true;
00759 m_mindex+=1;
00760 cout<<"m__RunNo="<<RunNo<<"m_mindex="<<m_mindex<<endl;
00761 }
00762
00763 ReadFilePar();
00764 }
00765 }
00766
00767 const MdcGeoWire * const
00768 MdcGeomSvc::Wire(unsigned id){
00769 if (id < fWires.size())
00770 return fWires[id];
00771
00772 return 0;
00773 }
00774
00775 const MdcGeoWire * const
00776 MdcGeomSvc::Wire(unsigned lyrid, unsigned wirid){
00777 if ((lyrid <fLayers.size()) && ((int) wirid < Layer(lyrid)->NCell()))
00778 return fWires[Layer(lyrid)->Wirst() + wirid];
00779
00780 return 0;
00781 }
00782
00783 const MdcGeoLayer * const
00784 MdcGeomSvc::Layer(unsigned id){
00785 if (id < fLayers.size())
00786 return fLayers[id];
00787
00788 return 0;
00789 }
00790
00791 const MdcGeoSuper * const
00792 MdcGeomSvc::SuperLayer(unsigned id){
00793 if (id < fSupers.size())
00794 return fSupers[id];
00795
00796 return 0;
00797 }
00798
00799 const MdcGeoGeneral * const
00800 MdcGeomSvc::GeneralLayer(unsigned id){
00801 if (id < fGenerals.size())
00802 return & fGenerals[id];
00803
00804 return 0;
00805 }
00806
00807 const MdcGeoMisc * const
00808 MdcGeomSvc::Misc(void){
00809 return & fMisc;
00810 }
00811
00812 const MdcGeoEnd * const
00813 MdcGeomSvc::End(unsigned id){
00814 if (id < fEnd.size())
00815 return fEnd[id];
00816
00817 return 0;
00818 }
00819
00820
00821 bool MdcGeomSvc::getSagFlag(void) {
00822
00823 return m_doSag;
00824 }
00825
00826