StRoot: StPmdReadMaker/StPmdReadMaker.cxx Source File

00001 /***************************************************************************
00002  *$Id: StPmdReadMaker.cxx,v 1.38 2011/08/17 11:45:51 rashmi Exp $
00003  *
00004  * StPmdReadMaker
00005  *
00006  * Author:  Supriya Das and Subhasis Chattopadhyay
00007  ***************************************************************************
00008  *
00009  * Description: Reading PMD data and filling hits for StEvent
00010  **************************************************************************
00011  *$Log: StPmdReadMaker.cxx,v $
00012  *Revision 1.38  2011/08/17 11:45:51  rashmi
00013  *year==12 27GeV  BadChains entered
00014  *
00015  *Revision 1.37  2011/06/01 16:45:28  rashmi
00016  *year==12 BadChains entered
00017  *
00018  *Revision 1.36  2011/04/26 13:14:27  rashmi
00019  *mVmeCond,BadChain info changed for year==12 data
00020  *
00021  *Revision 1.35  2010/07/06 16:30:45  rashmi
00022  *Calibration updates for run10
00023  *
00024  *Revision 1.34  2010/06/30 04:47:23  subhasis
00025  *reader fixed for reading daq files earlier than 2009 runs
00026  *
00027  *Revision 1.33  2010/05/31 22:11:09  rashmi
00028  *Edep of Pmdhit now hold calibrated ADC
00029  *
00030  *Revision 1.32  2010/04/16 12:09:40  rashmi
00031  *Modifcation for new DAQ
00032  *
00033  *Revision 1.31  2010/04/16 12:04:13  rashmi
00034  *Modifcation for new DAQ
00035  *
00036  *Revision 1.30  2008/11/18 12:47:11  rashmi
00037  *BadChains for dAu added
00038  *
00039  *Revision 1.29  2008/01/15 19:32:22  perev
00040  *No HOT CELLS, return with error flag
00041  *
00042  *Revision 1.28  2007/12/02 10:07:39  rashmi
00043  *Changing SMChain_GNF from MPVFactor to MeanFactor
00044  *
00045  *Revision 1.27  2007/11/17 15:50:46  rashmi
00046  *correcting setting of mCalibFlag
00047  *
00048  *Revision 1.26  2007/11/02 11:03:00  rashmi
00049  *Storing gains with hits, not applying gain calibration
00050  *
00051  *Revision 1.25  2007/10/26 18:13:17  rashmi
00052  *fixed some warnings
00053  *
00054  *Revision 1.24  2007/09/06 06:35:30  genevb
00055  *Small refinements to the BadChain fix
00056  *
00057  *Revision 1.23  2007/09/06 05:30:52  subhasis
00058  *Subhasis: BadChain fix to avoid cucu crash
00059  *
00060  *Revision 1.22  2007/09/05 03:41:42  genevb
00061  *Attribute check was in the wrong place
00062  *
00063  *Revision 1.21  2007/09/05 03:19:45  genevb
00064  *Use attribute pmdRaw
00065  *
00066  *Revision 1.20  2007/08/31 10:50:12  rashmi
00067  *Added routines to read badchains,HotCells,Cell_GNF,SMChain_GNF,Modified VMEcondition&ApplyMapping(subhasis)
00068  *
00069  *Revision 1.19  2007/07/12 19:52:05  fisyak
00070  *Add includes for ROOT 5.16
00071  *
00072  *Revision 1.18  2007/04/28 17:56:37  perev
00073  *Redundant StChain.h removed
00074  *
00075  *Revision 1.17  2007/04/26 04:14:27  perev
00076  *Remove StBFChain dependency
00077  *
00078  *Revision 1.16  2006/02/16 21:36:08  perev
00079  *No delete pmdCollection. It is deleted in Clear()
00080  *
00081  *Revision 1.15  2005/12/07 19:46:39  perev
00082  *EndCrashFix
00083  *
00084  *Revision 1.14  2005/01/27 13:08:51  subhasis
00085  *chaged to read 2005 data
00086  *
00087  *Revision 1.13  2004/09/22 19:24:56  perev
00088  *Leak fixed + mess with i,j indexes
00089  *
00090  *Revision 1.12  2004/07/12 14:45:08  subhasis
00091  *QA hist added
00092  *
00093  *Revision 1.11  2004/07/09 12:23:03  subhasis
00094  *numbering scheme adopted on CPV
00095  *
00096  *Revision 1.10  2004/07/09 10:40:09  subhasis
00097  *channel 0 ADC made to 0, numbering scheme implemented in fillStEvent, earlier it was done on StPmdHit, in stead of StPhmdHit
00098  *
00099  *Revision 1.9  2004/07/09 09:01:13  subhasis
00100  *numbering convention starts from 0 everywhere for filling StEvent
00101  *
00102  *Revision 1.8  2004/06/25 10:38:00  subhasis
00103  *vmecond bug fixed for 200 geV
00104  *
00105  *Revision 1.7  2004/04/14 15:40:41  subhasis
00106  *chainno 45,46 interchanged (in hardware) issue fixed
00107  *
00108  *Revision 1.6  2004/03/23 08:52:22  subhasis
00109  *several changes (Board Detail by hand etc) for first production
00110  *
00111  *Revision 1.5  2004/03/12 06:36:57  subhasis
00112  *fillStEvent argument orders done properly
00113  *
00114  *Revision 1.4  2004/03/11 11:29:46  subhasis
00115  *Changes made for PMD run config
00116  *
00117  *Revision 1.3  2003/12/03 11:50:29  subhasis
00118  *Comment header changed by Supriya
00119  *
00120  ***************************************************************************
00121  */
00122 
00123 //#include <Stiostream.h>
00124 #include "Stsstream.h"
00125 
00126 #include "StPmdReadMaker.h"
00127 #include "St_DataSetIter.h"
00128 
00129 #include "StDbLib/StDbManager.hh"
00130 #include "StDbLib/StDbTable.h"
00131 #include "StDbLib/StDbConfigNode.hh"
00132 
00133 #include "StGlobals.hh"
00134 #include "StPmdUtil/StPmdCollection.h"
00135 #include "StPmdUtil/StPmdDetector.h"
00136 #include "StPmdUtil/StPmdHit.h"
00137 #include "StPmdUtil/StPmdModule.h"
00138 #include "StPmdUtil/StPmdGeom.h"
00139 #include "StPmdUtil/StPmdDBUtil.h"
00140 #include<StMessMgr.h>
00141 #include "StRtsTable.h"
00142 #include "RTS/src/DAQ_PMD/pmd.h"
00143 
00144 //#include "RTS/src/EVP_READER/pmdReader.h"
00145 //
00146 // Interfaces
00147 //
00148 // DAQ Libraries
00149 #include "StDaqLib/GENERIC/EventReader.hh"
00150 #include "StDaqLib/PMD/PMD_Reader.hh"
00151 #include "StDAQMaker/StDAQReader.h"
00152 
00153 #include "TFile.h"
00154 // added for StEvent
00155 #include "StEvent/StEvent.h"
00156 #include "StEvent/StEventTypes.h"
00157 
00158 //added for cleanup 
00159 #include "StPmdCleanConstants.h"
00160 Int_t BadChainZero[25];
00161 Int_t * BadChain;
00162 Float_t SM_chain_factor[24][48];
00163 //ofstream fout("raw_5030002.dat");
00164 
00165 //
00166 ClassImp(StPmdReadMaker) // macro
00167 //-----------------------------------------------------------------
00168   
00169 StPmdReadMaker::StPmdReadMaker(const char *name) : StRTSBaseMaker("pmd",name)
00170 {
00171   mThePmdReader=NULL;
00172   mEvtPmdCollection=NULL;
00173   mPmdCollection=NULL;
00174   mTheDataReader=NULL;
00175   mThePmdData=NULL;
00176   mPmdEvent=NULL;  
00177   mCpvEvent=NULL;  
00178   mDb=NULL;
00179   m_PmdCalibConst=NULL;
00180   mPmdGeom = new StPmdGeom();
00181   mPmdDBUtil = new StPmdDBUtil();
00182   mChainTh=0;
00183 
00184   mCalibFlag=kFALSE;
00185   //  mCalibFlag=kTRUE;
00186 
00187   mPmdPrint=kFALSE;
00188   mHotCells=NULL;                                                          
00189 }
00190 
00191 //-----------------------------------------------------------------
00192 
00193 StPmdReadMaker::~StPmdReadMaker() {
00194   delete mPmdGeom;      mPmdGeom        =0;
00195   delete mPmdDBUtil;    mPmdDBUtil      =0;
00196   mThePmdReader =0;
00197   mTheDataReader=0;
00198   mThePmdData   =0;
00199   mPmdEvent     =0;
00200   mCpvEvent     =0;
00201   mPmdCollection=0;
00202   mDb=0;
00203   m_PmdCalibConst=0;
00204   mHotCells=0;
00205 }
00206 
00207 //-----------------------------------------------------------------
00208 
00209 Int_t StPmdReadMaker::Init() {
00210   if(mPmdPrint)gMessMgr->Info("StPmdReadMaker::Init()");
00211   mCalibFlag = !(IAttr("pmdRaw"));
00212   //  mCalibFlag = (IAttr("pmdRaw"));
00213   bookHist();
00214 
00215   return StMaker::Init();
00216 }
00217 //-----------------------------------------------------------------
00218 
00219 Int_t StPmdReadMaker::InitRun(Int_t runnr) {
00220   if(mPmdPrint)gMessMgr->Info("StPmdReaderMaker::InitRun()");
00221   
00222   mRunNumber = runnr;
00223   mPmdGeom->readBoardDetail(runnr);
00224   //  cout<<"PMDINITRUN*****runnr "<<runnr<<"   "<<mRunNumber<<endl;
00225   
00226   if(mRunNumber < 5034042) mVmeCond = 1;
00227   else if(mRunNumber >= 5034042 && mRunNumber < 5049020) mVmeCond = 2;
00228   else if(mRunNumber >= 5049020 && mRunNumber < 6000000) mVmeCond = 3;
00229   else if(mRunNumber >= 6000000 && mRunNumber < 7000000) mVmeCond = 4; // run 7 data
00230   else if(mRunNumber >= 8000000 && mRunNumber < 9000000) mVmeCond = 5; // run 7 data
00231   else if(mRunNumber >= 9000000) mVmeCond = 5; // run 7 data
00232   // // Subhasis: 7000000 to 8000000, this was pp , PMD was absent..
00233   // subhasis (25th aug 2007:) These conditions need to be checked very carefully
00234   
00235   //  cout<<"Run Number, VME Condition : "<<mRunNumber<<" "<<mVmeCond<<endl;
00236   // subhasis // to fix crash in BadChain
00237   for(Int_t i=0;i<25;i++) BadChainZero[i]=0;
00238   
00239   ReadBadChains(runnr);
00240   ReadCalibrationsConst();
00241   
00242   /*
00243     for(int ic=1;ic<=48;ic++){
00244     for(int sm = 1;sm<=24;sm++){
00245     if(SM_chain_factor[sm-1][ic-1]>0)cout<<sm<<","<<ic<<","<<SM_chain_factor[sm-1][ic-1]<<endl;
00246     }
00247     }
00248     
00249     for(int ic=1;ic<=48;ic++){
00250     for(int icl=0;icl<1728;icl++){
00251     if(IsHot(ic,icl))fout<<"HOT "<<ic<<" "<<icl<<endl;
00252     }
00253     }
00254   */
00255   
00256   return StMaker::InitRun(runnr);
00257 }
00258 
00259 //----------------------------------------------------
00260 
00261 void StPmdReadMaker::ReadBadChains(Int_t runNo){
00262   
00263   Int_t rn,year;
00264   mPmdGeom->GetRunYear(runNo,rn,year);
00265    if(Debug())cout<<"runNo="<<runNo<<" year="<<year<<endl;
00266   cout<<"runNo="<<runNo<<" year="<<year<<endl;
00267   
00268   if(year==12){
00269     if(runNo>12172000){
00270       BadChain = PmdClean::BadChain_y12d172;
00271     }else if(runNo>12114000){
00272       BadChain = PmdClean::BadChain_y12d114;
00273     }else{
00274       BadChain = PmdClean::BadChain_y12d0;
00275     }
00276     //    cout<<" I have read bad chains in this loop"<<endl;
00277    
00278   }
00279   
00280   if(year==11){
00281     if(runNo>11148001){
00282       BadChain = PmdClean::BadChain_y10d148;
00283     }else if(runNo>11105000){
00284       BadChain = PmdClean::BadChain_y10d105;
00285     }else if(runNo>11100000){
00286       BadChain = PmdClean::BadChain_y10d100;
00287     }else if(runNo>11091000){
00288       BadChain = PmdClean::BadChain_y10d91;
00289     }else if(runNo>11001000){
00290       BadChain = PmdClean::BadChain_y10d0;
00291     }
00292   }
00293 
00294 
00295   if(year==8){
00296     if(runNo>8342000){
00297       BadChain = PmdClean::BadChain_y8d342;
00298     }else if(runNo>8143000){
00299       BadChain = PmdClean::BadChain_y8d143;
00300     }else if(runNo>8135000){
00301       BadChain = PmdClean::BadChain_y8d135;
00302     }else if(runNo>8131000){
00303       BadChain = PmdClean::BadChain_y8d131;
00304     }else if(runNo>8122000){
00305       BadChain = PmdClean::BadChain_y8d122; // for year2007 data for day122-1\28
00306     }else if(runNo>8116000){
00307       BadChain = PmdClean::BadChain_y8d116; // for year2007 data for day116-1\21
00308     }else if(runNo>8108000){
00309       BadChain = PmdClean::BadChain_y8d108; // for year2007 data for day108-1\15
00310     }else if(runNo>8102000){
00311       BadChain = PmdClean::BadChain_y8d102; // for year2007 data for day102-1\07
00312     }else if(runNo > 8095000){
00313       BadChain = PmdClean::BadChain_y8d95; // for year2007 data for day95-100
00314     }else if(runNo>8089001){
00315       BadChain = PmdClean::BadChain_y8d89; // for year2007 data for day89-92
00316     }else{
00317       BadChain = PmdClean::BadChain_y8d0;
00318     }
00319   } else {
00320     BadChain = BadChainZero;
00321   }
00322   
00323   if (BadChain[0]>0 && Debug()){
00324     //  if (BadChain[0]>0){
00325     cout<<"BadChains are ";
00326     for(Int_t i=0;i<25;i++){
00327       if (BadChain[i]>0) cout<<BadChain[i]<<" ";
00328     }
00329     cout<<endl;
00330   }
00331   
00332 }
00333 
00334 //-------------------------------------------------------------------
00335 /*
00336 StRtsTable *StPmdReadMaker::GetNextLegacy(int sector)
00337 {
00338   TString pmdQuery = Form("legacy[%i]",sector);
00339   //  StRtsTable *daqPmdTable = GetNextLegacy();
00340   StRtsTable *daqPmdTable = GetNext(pmdQuery.Data());
00341   if (daqPmdTable) {
00342     return daqPmdTable;
00343   }
00344   return 0;
00345 }
00346 */
00347 //------------------------------------------------------------------
00348  /*
00349 StRtsTable *StPmdReadMaker::GetNextRaw(int sector)
00350 { 
00351   TString pmdRawQuery = Form("raw[%i]",sector);
00352   return GetNext(pmdRawQuery.Data());
00353 }
00354  */
00355 //------------------------------------------------------------------
00356 
00357 Int_t StPmdReadMaker::Make() {
00358   
00359   if(mPmdPrint)gMessMgr->Info("StPmdReadMaker::Make()");
00360   Int_t adc[2*PMD_CRAMS_MAX*2*(PMD_CRAMS_CH_MAX)];
00361   Int_t rn,year;
00362   mPmdGeom->GetRunYear(mRunNumber,rn,year);
00363   if(Debug())cout<<"runNo="<<mRunNumber<<" year="<<year<<endl;
00364   
00365   // The new daq was used after 2010
00366     
00367     Int_t adcChCount=0;
00368   //  Float_t Pmdhit[50]={0.};
00369   //  Float_t Pmdadc[50]={0.};
00370     
00371   //  Float_t pmdHIT=0.;
00372   //  Float_t pmdADC=0.;
00373     
00374     for (int sector=1; sector<2;++sector) {
00375       //      cout<<" sector = "<<sector<<endl;
00376       while ( GetNextLegacy(sector) ) {
00377         //
00378         pmd_t*  fpmd = (pmd_t*)*DaqDta()->begin();
00379         Int_t nChain=0;
00380         for(Int_t crate=0;crate<2;crate++) {
00381           //printf("Crate %s: status %d, mode %d\n",crate==0?"Up":"Dn",fpmd->status[crate],fpmd->mode) ;
00382           for(Int_t c=0;c<12;c++) {
00383             for(Int_t s=0;s<2;s++) {
00384               Int_t chmax = 0;
00385               Int_t chain = 0;
00386               for(Int_t ch=0;ch<1728;ch++) {
00387                 if(s==0){ nChain=c+12*crate;}
00388                 if(s==1){ nChain=(c+24)+12*crate;}
00389                 Double_t ped_mean= (double)fpmd->ped[crate][c][s][ch]/16.0;
00390                 Double_t ped_rms= (double)fpmd->rms[crate][c][s][ch]/16.0;
00391                 //Double_t ped_thr= (double)fpmd->thr[crate][c][s][ch]/16.0;
00392                 Int_t adc_ch = fpmd->adc[crate][c][s][ch];
00393                 if(adc_ch>0 && chmax<ch) {chmax = ch; chain = nChain;}
00394                 adc[adcChCount]=adc_ch;
00395                 adcChCount++;
00396         //      if(s==1 && ch>0 && adc_ch>0){
00397                   //pmdHIT++;
00398                   //pmdADC++;
00399                   //Pmdhit[nChain]++;
00400                   //Pmdadc[nChain]+=adc_ch;
00401         //      }
00402                 if(adc_ch>0 ||ped_mean>0){
00403                   chain_adc[nChain]->Fill(ch,adc_ch);
00404                   chain_mean[nChain]->Fill(ch,ped_mean);
00405                   chain_rms[nChain]->Fill(ch,ped_rms);
00406                   
00407                 //  printf("CRAM %2d: side %d: ch %4d: adc %4d [ped %4.1f, rms %4.2f, thr %4.1f]\n", c,s,ch, adc_ch, ped_mean, ped_rms, ped_thr) ;
00408                 }
00409               }
00410               //              cout<<"crate = "<<crate<<" c="<<c<<" s = "<<s<<" chmax="<<chmax<<" chain = "<<chain<<" boards = "<<(chmax*1.0)/64<<endl;
00411             }
00412           }
00413         }
00414         // do something
00415         // int ret=mThePmdReader->getAllPmdCpvData(&adc[0]);
00416         // if(ret){/*nothing*/}
00417         //   cout<<" I am calling applymapping"<<endl;
00418         Int_t result=ApplyMapping(&adc[0]);  
00419         //   cout<<" applymapping called"<<endl;
00420         if(result!=kStOK){gMessMgr->Info("Problem in getting PMD data:ApplyMap");
00421           return kStWarn;
00422         } 
00423       }
00424       //getting tofmultiplicity
00425   /*    
00426       
00427       StEvent *currevent = (StEvent*)GetInputDS("StEvent");
00428       // cout<<"+++++++++++++++++++++++================+++++++++++++++++"<<endl;
00429      // cout<<"getting stevent,id,pmd hit,adc "<<currevent->triggerIdCollection()->nominal()->isTrigger(270005)<<" "<<pmdHIT<<" "<<pmdADC<<endl;
00430       //cout<<"+++++++++++++++++++++++================+++++++++++++++++"<<endl;
00431 //      if(!currevent->triggerIdCollection()->nominal()->isTrigger(260024)) continue;
00432       
00433       //  cout<<" current event ="<<currevent<<endl;
00434       // cout<<"getting ctbm "<<endl;
00435       //  int ctbm=currevent->triggerData()->ctbSum(0);
00436       
00437       StTriggerData *theData =currevent->triggerData();
00438       
00439       //   cout<<"tofmultiplcity  "<<theData->tofMultiplicity()<<endl;
00440       StTriggerDetectorCollection *theTriggers =currevent->triggerDetectorCollection();
00441       
00442       StZdcTriggerDetector &theZdcTrg = theTriggers->zdc();
00443       StBbcTriggerDetector &theBbcTrg = theTriggers->bbc();
00444       StCtbTriggerDetector &theCtbTrg = theTriggers->ctb();
00445       //cout<<"444"<<theZdcTrg<<" "<<theBbcTrg<<" "<<theCtbTrg<<endl;
00446       
00447       Float_t  ZdcAdc=theZdcTrg.adcSum();
00448       Int_t   BbcAdc=theBbcTrg.adcSum();
00449       Double_t ctb = 0;
00450       for (unsigned int slat = 0; slat < theCtbTrg.numberOfSlats(); slat++) {
00451         for (unsigned int tray = 0; tray < theCtbTrg.numberOfTrays(); tray++) {
00452           ctb += theCtbTrg.mips(tray,slat,0);
00453         }
00454       }
00455       Int_t CtbMult = ctb;
00456       if(Debug()){cout<<"ZdcAdc="<<ZdcAdc<<" BbcAdc="<<BbcAdc<<" CtbMult="<<CtbMult<<endl;}
00457 */
00458 /*      
00459       if(pmdHIT>0){fout<<theZdcTrg.adcSum()<<" "<<theData->tofMultiplicity()<<" "<<pmdHIT<<" "<<pmdADC<<endl;
00460         for(Int_t ich=24;ich<48;ich++){
00461           fout<<ich<<" "<<Pmdhit[ich]<<" "<<Pmdadc[ich]<<endl; 
00462           Pmdhit[ich]=0.;
00463           Pmdadc[ich]=0.;
00464           
00465         }
00466       }
00467 */
00468       //fcout<<"ZDC , tof, pmd "<<theZdcTrg.adcSum()<<" "<<theData->tofMultiplicity()<<" "<<pmdhit<<" "<<pmdadc<<endl;
00469       //pmdhit_tof->Fill(pmdHIT,theData->tofMultiplicity());
00470       //pmdadc_tof->Fill(pmdADC,theData->tofMultiplicity());
00471       
00472       //cout<<"getting tofm "<<endl;
00473       //int tofm=(StTriggerData*)(currevent->triggerData())->tofMultiplicity(0);
00474       //
00475       //cout<<"------------------------------------------------------------   multiplicity :  tof   "<<tofm<<endl;
00476       
00477     }
00478   //#endif
00479     
00480   return kStOK;
00481 }
00482 
00483 
00484 Int_t StPmdReadMaker:: ApplyMapping(int *adc)
00485 {
00486   // Get Year of run
00487   /*
00488     char runfile[20];
00489     sprintf(runfile,"%d",mRunNumber);
00490     // Fetch from the run # the day
00491     char iRun[8];
00492     char iyear[8];
00493     for (Int_t ik=0; ik<3; ik++)
00494     {
00495     iRun[ik] = runfile[ik+1];
00496     }
00497     iyear[0] = runfile[0];
00498     Int_t year =0;
00499     year=atoi(iyear);
00500   */
00501   Int_t rn=0; Int_t year=0;
00502   mPmdGeom->GetRunYear(mRunNumber,rn,year);
00503   if(Debug())cout<<"runNo="<<mRunNumber<<" year="<<year<<endl;
00504   //  cout<<"Applymapping:: runNo="<<mRunNumber<<" year="<<year<<" day="<<rn<<endl;
00506  if(mRunNumber<1){
00507    gMessMgr->Info("Run number >11 , returning from applymapping ");
00508    return kStWarn;
00509  }
00510   mPmdGeom->readBoardDetail(mRunNumber); 
00511   
00512   mPmdCollection = new StPmdCollection("PmdCollection");
00513   m_DataSet->Add(mPmdCollection);
00514   StPmdDetector* det0 = mPmdCollection->detector(0); 
00515   StPmdDetector* det1 = mPmdCollection->detector(1); 
00516   //  cout<<"Applymapp: Run Number, VME Condition : "<<mRunNumber<<" "<<mVmeCond<<endl;
00517   
00518   Int_t Chain_No,supmod,row,col,SubDet=0,chtemp;
00519   Int_t AddCh_Count=0;
00520   Int_t orig_nhits = 0;
00521   Int_t nhits=0;
00522   Int_t nhits_sm[24]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
00523   for(Int_t SEC=0; SEC < PMD_SECTOR; SEC++){               //PMD_SECTOR = 2
00524     for(Int_t CRAM=0; CRAM < PMD_CRAMS_MAX; CRAM++){       //PMD_CRAMS_MAX = 12
00525       for(Int_t BLOCK=0; BLOCK < PMD_CRAMS_BLOCK; BLOCK++){//PMD_CRAMS_BLOCK = 2
00526         for(Int_t CHANNEL=0; CHANNEL < PMD_CRAMS_CH_MAX; CHANNEL++){ //PMD_CRAMS_CH_MAX = 1728
00527           Int_t channel=CHANNEL;  // Input to apply mapping should be 0-1727.
00528           
00529           //Added for diffrent VME Crate conditions ////////////
00530           
00531           switch (mVmeCond){
00532             
00533           case 1: 
00534             {
00535               if(SEC==0){
00536                 if(BLOCK==0)Chain_No=25+CRAM;
00537                 if(BLOCK==1)Chain_No=37+CRAM;
00538               } 
00539               else break;             
00540             }
00541             break; 
00542           case 2: 
00543             {
00544               Chain_No=(CRAM+1)+(SEC*PMD_CRAMS_MAX)+(BLOCK*2*PMD_CRAMS_MAX);
00545             }
00546             break;
00547           case 3:
00548             {
00549               if(SEC==0 && BLOCK==0 && CRAM==9) Chain_No = 39;
00550               else if(SEC==0 && BLOCK==0 && CRAM==10) Chain_No = 40;
00551               else Chain_No=(CRAM+1)+(SEC*PMD_CRAMS_MAX)+(BLOCK*2*PMD_CRAMS_MAX); 
00552             }
00553             break;
00554           case 4:   // 2005 data
00555             {
00556               if(SEC==0 && BLOCK==0 && CRAM==5) Chain_No = 36;
00557               else Chain_No=(CRAM+1)+(SEC*PMD_CRAMS_MAX)+(BLOCK*2*PMD_CRAMS_MAX); 
00558             }
00559             break;
00560           case 5:   // 2006-7 data
00561             {
00562               // !!! this needs to be checked
00563               if(SEC==0 && BLOCK==0 && CRAM==5) Chain_No = 36;
00564               else Chain_No=(CRAM+1)+(SEC*PMD_CRAMS_MAX)+(BLOCK*2*PMD_CRAMS_MAX);
00565             }
00566             break;
00567           }
00568           if(mVmeCond==4){
00569             // On 18th access it was found that I/P to chain 45 and 46 are interchanged,
00570             //    (see log book for details).
00571             Int_t Chain_original=Chain_No;
00572             if(Chain_original==45)Chain_No=46;
00573             if(Chain_original==46)Chain_No=45;
00574             //Chain_No goes from 1 to 48
00575           }
00576           //   VME Condition Ends ///////////////////////////////////
00577           
00578           // Setting the SubDetector No.
00579           
00580           if (Chain_No >= 1 && Chain_No < 25) SubDet = 2; 
00581           if (Chain_No >= 25 && Chain_No <= 48) SubDet = 1; 
00582           
00583           
00584           // Apply Mapping to get the sm, row and col here
00585           //     initialise the refs.  
00586           Int_t mapp=0;
00587           supmod=0;
00588           row=0;
00589           col=0;
00590           chtemp=-1;
00591 
00592           if(mRunNumber < 6000000)mapp=mPmdGeom->ChainMapping(Chain_No,channel,supmod,col,row,chtemp);  // 2004 data
00593           if(mRunNumber >= 6000000)mapp=mPmdGeom->ChainMapping(Chain_No,channel,supmod,col,row,chtemp,year);  // 2005 onwards data
00594           Int_t DaqADC=adc[AddCh_Count];
00595           // zeroing zeroeth channel
00596           if(channel==0)DaqADC=0;
00597           
00598           AddCh_Count++;
00599           
00600           if(DaqADC>0 && mapp==kStOK){
00601             orig_nhits++;
00602             //Fill chain-channel QA
00603             m_chain_channel->Fill(channel,Chain_No-1);
00604             
00605             // Apply uniformity calibration here
00606             //
00607             Float_t cellgain = 1;
00608             Float_t smchaingain = 1;
00609             Float_t cellstatus = 1;
00610             //fout<<" "<<mRunNumber<<" "<<supmod<<" "<<row<<" "<<col<<" "<<DaqADC<<endl;
00611             //cout<<" "<<mRunNumber<<" "<<supmod<<" "<<row<<" "<<col<<" "<<DaqADC<<endl;
00612             if(mCalibFlag){
00613               Float_t calib = 1;
00614               Float_t final_factor = 0;
00615               
00616               if(supmod<=(2*PMD_CRAMS_MAX) && row <=PMD_ROW_MAX && col <=PMD_COL_MAX){
00617                 
00618                 Int_t stCalib = GetCalib(supmod,row,col,calib); 
00619                 if(stCalib != kStOK)gMessMgr->Info("Problem in getting Calibration Constant");
00620                 
00621                 if(mRunNumber < 8000000){
00622                   //                  final_factor=calib;
00623                   final_factor=1.;
00624                 }
00625                 if(mRunNumber >= 8000000){
00626                   //storing gain factors for StPmdHit to be used in ClusterMaker
00627                   cellgain=calib;
00628                   smchaingain=SM_chain_factor[supmod-1][Chain_No-1];
00629                   // application of finalfactor
00630                   final_factor=calib*SM_chain_factor[supmod-1][Chain_No-1];
00631                   //              fout<<"ADC, chain, row, col, calib, sm_chain "<<DaqADC<<" "<<Chain_No<<" "<<row<<" "<<col<<" "<<calib<<" "<<SM_chain_factor[supmod-1][Chain_No-1]<<" final_factor="<<final_factor<<endl;
00632                   if(!Accept(Chain_No,channel)){
00633                     final_factor=0.0;
00634                     cellstatus=0;
00635                   }
00636                   //          if(SubDet==1) fout<<supmod-1<<" "<<col-1<<" "<<row-1<<" "<<calib<<" "<<smchaingain<<" "<<cellstatus<<endl;
00637                 }
00638                 //if(calib!=0)DaqADC=(Int_t)(DaqADC*calib);
00639                 //
00640                 //                              cout<<supmod<<","<<row<<","<<col<<","<<Chain_No<<","<<calib<<","<<SM_chain_factor[supmod-1][Chain_No-1]<<","<<final_factor<<","<<DaqADC<<endl;;
00641                 if(final_factor>0){
00642                   //subhasi: stop applying gain factor here, apply in clusterMaker
00643                   //                  DaqADC=(Int_t)(1.0*DaqADC/final_factor);
00644                 }else{
00645                   //                  DaqADC=0;
00646                 }
00647                 
00648                 
00649               } //Check on overflow of supmod, row col
00650             } // Calibration flag     
00651             
00652             // Converting ADC to Edep
00653             Float_t edep=0;
00654             //      mPmdGeom-> ADC2Edep(DaqADC, edep);
00655             // The old edep was a function of ADC itself available in StPmdGeom.
00656             // cell_status = 0 for cells for which calibration is not available
00657             // cell_status = 1 for cells for which calibration is available
00658             // final factor is the cellGNF*SMChainGNF for all cleaned cells
00659             //      cout<<"DaqADC="<<DaqADC<<" cellgain  = "<<cellgain<<" smchaingain = "<<smchaingain<<" cellstatus="<<cellstatus<<endl;
00660             edep = DaqADC *cellstatus/(cellgain*smchaingain);
00661             if(edep<0) edep=0;
00662             
00663             if(DaqADC>0){
00664               //                cout<<"sm, row, col,adc, edep "<<supmod<<","<<row<<","<<col<<","<<DaqADC<<" "<<edep<<endl;;
00665               //Fill StPmdHit
00666               StPmdHit *pmdhit = new StPmdHit();
00667               nhits_sm[supmod-1]++;
00668               if(supmod>PMD_CRAMS_MAX)supmod-=PMD_CRAMS_MAX;
00669               pmdhit->setGsuper(Int_t(supmod));      
00670               pmdhit->setSubDetector(Int_t(SubDet)); 
00671               pmdhit->setRow(Int_t(row));            
00672               pmdhit->setColumn(Int_t(col));         
00673               pmdhit->setAdc(Int_t(DaqADC));         
00674               pmdhit->setEdep(Float_t(edep));        
00675               // gain related
00676               pmdhit->setGainCell(Float_t(cellgain));        
00677               pmdhit->setGainSmChain(Float_t(smchaingain));        
00678               pmdhit->setCellStatus(Float_t(cellstatus));        
00679               
00680               if(SubDet==2)det0->addHit(pmdhit);
00681               if(SubDet==1)det1->addHit(pmdhit);
00682               nhits++;
00683             } // Check on non zero DaqADC after calibration and Accept()
00684             
00685           } //Check on non zero DaqADC
00686           
00687         } //CHANNEL
00688       } //BLOCK
00689     } //C-RAM
00690   } //SEC
00691   
00692   if(Debug()){
00693     cout<<" NUmber of channels read ="<<AddCh_Count<<endl;
00694     cout<<" NUmber of original hits ="<<orig_nhits<<endl;
00695     cout<<" number of hits="<<nhits<<endl;
00696     for(Int_t ism = 0;ism<24;ism++){
00697       if(nhits_sm[ism]>0) cout<<"number of hits in module "<<ism+1<<" is ="<<nhits_sm[ism]<<endl;
00698     }
00699   }
00700   if(mPmdPrint)gMessMgr->Info("StEvent to be called **");
00701   Int_t testevt=fillStEvent(det0,det1);  //called as (cpv_det,pmd_det)
00702   if(testevt!=kStOK){
00703         gMessMgr->Info("Problem in fillStEvent");
00704         return kStWarn;
00705   }
00706 //
00707   return kStOK;
00708 }
00709 //-------------------------------------------------------------------------
00710 
00711 Int_t StPmdReadMaker::fillStEvent(StPmdDetector* cpv_det, StPmdDetector* pmd_det){
00712   // Look for StEvent
00713   StEvent *currevent = (StEvent*)GetInputDS("StEvent");
00714   //
00715   if(!currevent){
00716     gMessMgr->Info("NO STEVENT**");
00717     //     StEvent *currevent=new StEvent();
00718     
00719     return kStWarn;
00720   }
00721 //  Int_t ctbm=currevent->triggerData()->ctbSum(0);
00722 //  Int_t tofm=currevent->triggerData()->tofMultiplicity(0);
00723   // Create PhmdCollection, first Maker in Chain, so here it is created
00724   mEvtPmdCollection = new StPhmdCollection();
00725   currevent->setPhmdCollection(mEvtPmdCollection);
00726   
00727   //Set the Detectors to PhmdCollection
00728   if(mEvtPmdCollection){
00729     mPmdEvent = mEvtPmdCollection->detector(StDetectorId(kPhmdId)); 
00730     mCpvEvent = mEvtPmdCollection->detector(StDetectorId(kPhmdCpvId));
00731   }
00732   Int_t tothit_pmd=0;
00733   Int_t tothit_cpv=0;
00734   
00735   //  StEventInfo* eventInfo = currevent->info();
00736   //  Int_t Nevent=eventInfo->id();
00737   
00738   //  if(!mEvtPmdCollection){
00739   //  cout<<"No PMDCOLLECTION **, Creating one"<<endl;
00740   //  mEvtPmdCollection = new StPhmdCollection();
00741   //  currevent->setPhmdCollection(mEvtPmdCollection);
00742   //  mPmdEvent = mEvtPmdCollection->detector(StDetectorId(kPhmdId)); 
00743   //  mCpvEvent = mEvtPmdCollection->detector(StDetectorId(kPhmdCpvId));
00744   //}
00745   
00746   for(Int_t id=1;id<(PMD_CRAMS_MAX+1);id++){
00747     
00748     //Fill StEvent info for PMD and CPV, first PMD(subdet=1)
00749     //does the id goes from 1 to 12 for PmdHit (for PhmdHit it goes 0-11).
00750     
00751     StPmdModule * pmd_mod=pmd_det->module(id);
00752     Int_t nmh1=pmd_det->module_hit(id);
00753     
00754     if(nmh1>0){
00755       //      cout<<" PMD: Filled "<<nmh1<<" hits in Pre"<<endl;
00756       TIter next(pmd_mod->Hits());
00757       StPmdHit *spmcl1;
00758       for(Int_t im=0; im<nmh1; im++)
00759         {
00760           spmcl1 = (StPmdHit*)next();
00761           if(spmcl1){
00762             Int_t subdet=spmcl1->SubDetector();
00763             Int_t gsuper=spmcl1->Gsuper();
00764             Int_t col=spmcl1->Column();
00765             Int_t row=spmcl1->Row();
00766             Float_t edep=spmcl1->Edep();
00767             Int_t adc=spmcl1->Adc();
00768             
00770             
00771             StPhmdHit *phit = new StPhmdHit();
00772             /*
00773               phit->setSuperModule(Int_t(gsuper-1)); // filling supermodule no (range 0-11)
00774               phit->setSubDetector(Int_t(subdet));   // filling subdetector
00775               phit->setRow(Int_t(row));              // filling row
00776               phit->setColumn(Int_t(col));           // filling col
00777               phit->setEnergy(edep);                 // filling energy
00778               phit->setAdc(adc);                     // filling ADC
00779             */
00780             // changed to accommodate numbering scheme (i.e start from 0)
00781             phit->setSuperModule(Int_t(gsuper-1)); // filling supermodule no (range 0-11)
00782             phit->setSubDetector(Int_t(subdet-1));   // filling subdetector (pmd=0,cpv=1)
00783             phit->setRow(Int_t(row-1));              // filling row (starts from 0)
00784             phit->setColumn(Int_t(col-1));           // filling col (starts from 0)
00785             phit->setEnergy(edep);                 // filling energy
00786             phit->setAdc(adc);                     // filling ADC
00787             tothit_pmd++;
00788             if(mPmdEvent)mPmdEvent->addHit(phit);
00789           }
00790         }
00791     }
00792     
00793     //Now CPV (subdet=2)    //////
00794     
00795     Int_t nmh2=cpv_det->module_hit(id);
00796     StPmdModule * cpv_mod=cpv_det->module(id);
00797     
00798     if(nmh2>0)
00799       {
00800         cout<<" PMD: Filled "<<nmh2<<" hits in CPV"<<endl;
00801         TIter next(cpv_mod->Hits());
00802         StPmdHit *spmcl2;
00803         for(Int_t im=0; im<nmh2; im++)
00804           {
00805             spmcl2 = (StPmdHit*)next();
00806             if(spmcl2){
00807               Int_t subdet=spmcl2->SubDetector();
00808               Int_t gsuper=spmcl2->Gsuper();
00809               Int_t col=spmcl2->Column();
00810               Int_t row=spmcl2->Row();
00811               Float_t edep=spmcl2->Edep();
00812               Int_t adc=spmcl2->Adc();
00813               
00814               StPhmdHit *phit = new StPhmdHit();
00815               
00816               // changed to accommodate numbering scheme (i.e start from 0)
00817               phit->setSuperModule(Int_t(gsuper-1)); // filling supermodule no (range 0-11)
00818               phit->setSubDetector(Int_t(subdet-1));   // filling subdetector (pmd=0,cpv=1)
00819               phit->setRow(Int_t(row-1));              // filling row (starts from 0)
00820               phit->setColumn(Int_t(col-1));           // filling col (starts from 0)
00821               phit->setEnergy(edep);                 // filling energy
00822               phit->setAdc(adc);                     // filling ADC
00823               
00824               tothit_cpv++;
00825               if(mCpvEvent)mCpvEvent->addHit(phit);
00826             }
00827           }
00828       }
00829   }
00830   //  m_event_tothit_pmd->Fill(Nevent,tothit_pmd);
00831   //  m_event_tothit_cpv->Fill(Nevent,tothit_cpv);
00832   
00833   return kStOK;
00834 }
00835 
00836 //------------------------------------------------------------------
00837 
00838 Int_t StPmdReadMaker::Finish() {
00839   if(mPmdPrint)gMessMgr->Info("StPmdReadMaker::Finish()");
00840   TFile * f = new TFile("11030019run_2010_histo_QA.root", "RECREATE");  
00841   for(Int_t nchain=0; nchain<49; nchain++)
00842     {
00843       chain_mean[nchain]->Write();
00844       chain_rms[nchain]->Write();
00845       chain_adc[nchain]->Write();
00846     }
00847   pmdhit_tof->Write();
00848   pmdadc_tof->Write();
00849   f->Close();
00850   return StMaker::Finish();
00851 }
00852 
00853 //------------------------------------------------------------------
00854 
00855 void StPmdReadMaker::bookHist(){
00856   //m_event_tothit_pmd = new TH1F("pmd_tothit","tothit vs eventNo (PMD)",10000,0,100000);
00857   //m_event_tothit_cpv = new TH1F("cpv_tothit","tothit vs eventNo (CPV)",10000,0,100000);
00858   pmdhit_tof = new TH2F("pmdhit_tof","",1000,0,100000, 1000, 0, 10000);
00859   pmdadc_tof = new TH2F("pmdadc_tof","",1000,0,100000, 1000, 0, 10000);
00860   
00861   m_chain_channel = new TH2F("chain_chan","channel vs chain No ",1728,-0.5,1727.5,48,-0.5,47.5);
00862   for (Int_t chain1 =0;chain1<49;chain1++)
00863     {
00864       Char_t text[20],title[20];
00865       sprintf(text,"chain_rms%02d",chain1);
00866       sprintf(title,"chain_rms%02d",chain1);
00867       chain_rms[chain1] = new TH1D(text,title,1730,0,1730);
00868       sprintf(text,"chain_mean%02d",chain1);
00869       sprintf(title,"chain_mean%02d",chain1);
00870       chain_mean[chain1] = new TH1D(text,title,1730,0,1730);
00871       Char_t text1[20],title1[20];
00872       sprintf(text1,"chain_adc%02d",chain1);
00873       sprintf(title1,"chain_adc%02d",chain1);
00874       chain_adc[chain1] = new TH1D(text1,title1,1730,0,1730);
00875     }
00876 }
00877 
00878 //---------------------------------------------------------------------
00879 Bool_t StPmdReadMaker::IsHot(Int_t chain,Int_t channel){
00880   // Find out if a given chain/channel is "hot"
00881   // DB stores element IDs 1-48 => table rows 0-47 => chains 1-48
00882   // DB stores 1728 channels as 54 x 32bit words (1-1728)
00883   if (!mHotCells) return kFALSE;
00884   
00885   //   channel--;
00886   Int_t offset = channel/32;
00887   Int_t bit = channel%32;
00888   
00889   pmdHotCells_st* chainCells = mHotCells->GetTable(chain-1);
00890   unsigned int* bitMask = &(chainCells->m00);
00891   bitMask += offset;
00892   Bool_t isHot = ( ((*bitMask) & (((unsigned int) 1) << (31-bit))) != 0 );
00893   //   static int isHotCount = 0;
00894   if (isHot) {
00895     //     isHotCount++;
00896     //    cout<<" isHot: "<< isHotCount << endl;
00897     //    mHotTracks++;
00898     //    if(Debug())cout<<"chain/channel="<<chain<<"  "<<channel<<endl;
00899     //    cout<<"in IsHOT: chain/channel="<<chain<<"  "<<channel<<endl;
00900   }
00901   // temporarily put here by RR
00902   // to remove chain 11 and chain 13
00903   // if (chain==11|| chain==13) isHot=kTRUE;
00904   return isHot;
00905 }
00906 
00907 //----------------------------------------------------------
00908 
00909 Bool_t StPmdReadMaker::Accept(Int_t chain,Int_t channel){
00910                                                                                        
00911   if (channel==0)return kFALSE;
00912   // This should have access to database of hot channels according to year
00913                                                                                        
00914   for(Int_t i=0;i<25;i++){
00915     // if the chain is not to be included in the analysis for some reason
00916     if (chain==BadChain[i]){
00917       //      fout<<"BadChain="<<BadChain[i]<<endl;
00918       return kFALSE;
00919     }
00920   }
00921   //  Int_t chain_channel = chain*1728+channel;
00922   //  return !IsHot(chain_channel);
00923   return !IsHot(chain,channel);
00924   
00925 }
00926 
00927 //----------------------------------------------------------------------
00928 
00929 Bool_t StPmdReadMaker::ReadCalibrationsConst(){
00930   
00931   if(Debug()) cout<<" StPmdReadMaker::I AM IN READCALIB "<<endl;
00932   
00933   StDbManager* mgr=StDbManager::Instance();
00934   StDbConfigNode* node=mgr->initConfig("Calibrations_pmd");
00935   node->setVersion("SMChain");
00936   
00937   mDb=NULL;
00938   m_PmdCalibConst=NULL;
00939   TString DbName = "Calibrations/pmd";
00940   mDb=GetInputDB(DbName.Data());
00941   if(Debug())cout<<"after mDB"<<endl;
00942   if(!mDb) return kFALSE;
00943   //  fout<<"after !mDb"<<mDb->GetTimeStamp()<<endl;
00944   
00945   for(Int_t ism=0;ism<24;ism++){
00946     for(Int_t chain=0;chain<48;chain++){
00947       SM_chain_factor[ism][chain]=0.;
00948     }
00949   }
00950   //getting tables ////////////////////////////////////////////////////
00951   
00952   // Cell_GNF Tables
00953   pmdCalSummary_st* pmdcalsum = NULL;
00954   St_pmdCalSummary* summ = (St_pmdCalSummary*) mDb->Find("pmdCalSummary");
00955   if(summ) pmdcalsum = summ->GetTable();
00956   
00957   pmdSMCalib_st* pmdcalibst = NULL;
00958   TString TableName;
00959   St_pmdSMCalib* a = (St_pmdSMCalib*) mDb->Find("pmdSMCalib");
00960   if(a) pmdcalibst = a->GetTable();
00961   if(!pmdcalibst) return kFALSE;
00962   m_PmdCalibConst=pmdcalibst;
00963   if(Debug())cout<<"obtained the Cell_GNF Tables"<<endl;
00964   
00965   // HOT CELLS
00966   mHotCells = (St_pmdHotCells*) mDb->Find("pmdHotCells");
00967   if (!mHotCells) {
00968     gMessMgr->Warning("pmdHotCells not found!");
00969     return kFALSE;
00970   }
00971   Int_t nhot = 0;
00972   for (Int_t chain=1; chain <= 48; chain++) {
00973     pmdHotCells_st* chainCells = mHotCells->GetTable(chain-1);
00974     if (!chainCells) {
00975       cout<<"End-of-DbTable. Stopping."<<endl;
00976       return kFALSE;
00977     }
00978     
00979     for (Int_t offset=0; offset<54; offset++) {
00980       unsigned int* bitMask = &(chainCells->m00);
00981       bitMask += offset;
00982       //      if (*bitMask!=0)cout<<chain<<" "<<offset<<"  "<<*bitMask<<endl;
00983       for (Int_t bit=31; bit>=0; bit--) {
00984         if ( ((*bitMask) & (((unsigned int) 1) << bit)) != 0 ) {
00985           //      Int_t channel = offset*32 + (31-bit);
00986           //            printf("%2d %4d",chain,channel);
00987           //      fout<<bit<<"  "<<chain<<" "<<channel<<endl;
00988           nhot++;
00989         }
00990       }
00991     }
00992     
00993   }
00994   if(Debug()) cout<<" number of hot cells is "<< nhot<<endl;
00995   //cout<<"PMD:  number of hot cells is "<< nhot<<endl;
00996   
00997   // SM_CHAIN_GNF
00998   
00999   St_pmdSMChain_GNF * tab = (St_pmdSMChain_GNF*) mDb->Find("pmdSMChain_GNF");
01000   if (!tab) {
01001     cout<<"No pmdSMChain_GNF DBTable. Stopping."<<endl;
01002     return kFALSE;
01003   }
01004   
01005   //  cout<<"Got SmChain tables"<<endl;
01006   //  int sm,chain;
01007   //  float meancor,meancor_err,mpvcor,mpvcor_err;
01008   
01009   //  fout<<"Reading SMChain_GNF "<<endl;
01010   
01011   for (Int_t ismchain=0; ismchain<64; ismchain++) {
01012     pmdSMChain_GNF_st* smchain = tab->GetTable(ismchain);
01013     if (!smchain) {
01014       cout<<"End-of-SmChain DbTable. Stopping."<<endl;
01015       return kFALSE;
01016     }
01017     // Range of SM, Chain: from 0 or 1
01018     long supmod = smchain->sm;
01019     long chainNo=smchain->chain;
01020     float MeanFactor = smchain->mean_factor;
01021     float MPVFactor = smchain->mpv_factor;
01022     //    SM_chain_factor[supmod-1][chainNo-1]=MPVFactor;
01023     SM_chain_factor[supmod-1][chainNo-1]=MeanFactor;
01024     
01025     //struct pmdSMChain_GNF {
01026     //   long sm;              /* super module */
01027     //   long chain;           /* chain */
01028     //   float mean_factor;    /* mean */
01029     //   float errmean_factor; /* error on mean */
01030     //   float mpv_factor;     /* most probable value */
01031     //   float errmpv_factor;  /* error on mpv */
01032     //};
01033     if(Debug()){
01034       if(supmod>0 && chainNo>0){
01035         cout<<"SM,Chain,mean_factor,mpv_factor "<<supmod<<" "<<chainNo<<" "<<MeanFactor<<" "<<MPVFactor<<" "<<SM_chain_factor[supmod-1][chainNo-1]<<endl;
01036       }
01037     }
01038   }
01039   return kTRUE;
01040   
01041 }
01042 
01043 //------------------------------------------------------------------
01044 
01045 Int_t StPmdReadMaker::GetCalib(int sm,int row,int col,float& calib)
01046 {
01047   if(sm>0 && row>0 && col>0)
01048     if(m_PmdCalibConst)calib=m_PmdCalibConst[sm-1].CellGain[row-1][col-1];
01049   
01050   //  cout<<"sm,row,col,calib"<<sm<<" "<<row<<" "<<col<<" "<<calib<<endl;
01051   //  if(Debug() && calib>0)fout<<"sm,row,col,calib "<<sm<<" "<<row<<" "<<col<<" "<<calib<<endl;
01052   return kStOK;
01053   
01054 }
01055 
01056 //------------------------------------------------------------------------------