StRoot: StSpinPool/StSpinDbMaker/StSpinDbMaker.cxx Source File

00001 // *-- Author : Jan Balewski
00002 // 
00003 // $Id: StSpinDbMaker.cxx,v 1.14 2009/10/03 03:16:26 balewski Exp $
00004  
00005 
00006 #include <time.h>
00007 #include <string.h>
00008 
00009 #include <TDatime.h>
00010 #include "St_db_Maker/St_db_Maker.h"
00011 
00012 #include "StSpinDbMaker.h"
00013 
00014 #include "tables/St_spinDbV124_Table.h"
00015 #include "tables/St_spinDbStar_Table.h"
00016 #include "tables/St_spinDbBXmask_Table.h"
00017 
00018 #include <StMessMgr.h>
00019 
00020 ClassImp(StSpinDbMaker)
00021 
00022 //________________________________________________________
00023 //________________________________________________________
00024 StSpinDbMaker::StSpinDbMaker(const char *name):StMaker(name){
00025   gMessMgr->Message("","D") <<GetName()<<endm;
00026   setDBname("Calibrations/rhic");
00027   mNFound=0;
00028 }
00029 
00030 
00031 //________________________________________________________
00032 //________________________________________________________
00033 //_______________________________________________________
00034 StSpinDbMaker::~StSpinDbMaker(){
00035 
00036 }
00037 
00038 
00039 //________________________________________________________
00040 //________________________________________________________
00041 //________________________________________________________
00042 Int_t 
00043 StSpinDbMaker::Init(){
00044   return StMaker::Init();
00045 }
00046 
00047 //__________________________________________________
00048 //__________________________________________________
00049 //__________________________________________________
00050 void  
00051 StSpinDbMaker::clearTables(){
00052   mDbDate=19990000;  
00053   mNFound=0;
00054   mTabSpinV124=0;
00055   mTabSpinStar=0;
00056   mTabSpinBXmask=0;
00057   int i;
00058   for(i=0;i<SPINDbMaxBXings;i++) {
00059     spin8bits[i]=-1;
00060     spin4bits[i]=-1;
00061   }
00062 
00063   for(i=0;i<SPINDbMaxRing;i++) mNfilledBunches[i]=-2;
00064   mCADpolPattern="noLabel";
00065 }
00066 
00067 //__________________________________________________
00068 //__________________________________________________
00069 //__________________________________________________
00070 Int_t  
00071 StSpinDbMaker::InitRun  (int runNumber){
00072   LOG_INFO << GetName()<<"::InitRun=  " <<runNumber <<endm;
00073   clearTables();
00074   requestDataBase();
00075  
00076   if(mTabSpinV124) { 
00077     auxilairyVariables();
00078     optimizeTables();
00079   }
00080 
00081   LOG_DEBUG << GetName()<<"::InitRun()  nFound "<< mNFound<<" SPIN related tables "<<endm;
00082 
00083   return StMaker::InitRun(runNumber);
00084 }  
00085 
00086 
00087 //__________________________________________________
00088 //__________________________________________________
00089 
00090 void  StSpinDbMaker::requestDataBase(){
00091   
00092   LOG_DEBUG <<Form ("%s::reloadDb using TimeStamp from 'StarDb'=%p or 'db'=%p ",GetName(),(void*)GetMaker("StarDb"),(void*)GetMaker("db"))<<endm;
00093   
00094 
00095   St_db_Maker* stdb = (St_db_Maker*)GetMaker("StarDb");
00096   if(stdb==0) stdb = (St_db_Maker*)GetMaker("db");// try the other name
00097   assert(stdb);
00098   mDbDate = stdb->GetDateTime().GetDate();
00099    
00100   StEvtHddr* fEvtHddr = (StEvtHddr*)GetDataSet("EvtHddr");
00101   
00102   LOG_INFO << GetName()<<"::RequestDataBase(),\n     event time stamp="<< (int)fEvtHddr->GetUTime()<< " , yyyy/mm/dd="<< fEvtHddr->GetDate()<<" hh/mm/ss="<<fEvtHddr->GetTime()<<endm;  
00103   
00104   LOG_DEBUG << GetName()<<"::RequestDataBase(), access DB='"<<mDbName<<"'  use timeStamp="<< stdb->GetDateTime().AsString()<<endm;
00105   
00106   TDataSet *spindb=GetDataBase(mDbName );
00107   if(spindb==0) {
00108     LOG_ERROR << GetName()<<"::RequestDataBase()  Could not find dbName ="<<mDbName <<endm;
00109     return ;
00110     // down-stream makers should check for presence of dataset
00111   }
00112   // spindb->ls(2);  
00113   getTable<St_spinDbV124,spinDbV124_st>(spindb,"spinV124",&mTabSpinV124);    
00114   getTable<St_spinDbStar,spinDbStar_st>(spindb,"spinStar",&mTabSpinStar);  
00115   getTable<St_spinDbBXmask,spinDbBXmask_st>(spindb,"spinBXmask",&mTabSpinBXmask);  
00116    
00117    LOG_INFO << GetName()<<"::Request isValid="<< isValid()<<endm;
00118 
00119 
00120 }
00121  
00122 //__________________________________________________
00123 //__________________________________________________
00124 //__________________________________________________
00125 
00126 void  StSpinDbMaker::optimizeTables  (){
00127   /* labels of spin state for one beam 
00128      using respective nibble from 8-spinBit word
00129      0 = unpol&filled, nibble=1001
00130      + = up&filled   , nibble=0011
00131      - = down&filled , nibble=0101
00132      E = empty&filled, nibble=0000
00133      X = not allowed, any other nibble
00134   */
00135   
00136   //        Zero    Posit   Negat   Empty
00137   const int nibZ=9, nibP=3, nibN=5, nibE=0;
00138   // printf("optimizeTables: bucketOffset: B=%d Y=%d\n",mTabSpinV124->bucketOffset[blueRing],mTabSpinV124->bucketOffset[yellRing]);
00139   
00140   int bx;
00141   int nP2=0,nP1=0,nP0=0,nPer=0;
00142   for(bx=0;bx<SPINDbMaxBXings;bx++){
00143     // ..... find correct time bucket for pattern rotation in each ring
00144     // this is tricky: bx is in STAR IP, but bBucket & yBucket have subtracted offsets modulo 120 !
00145     int bBucket=(bx*3+mTabSpinV124->bucketOffset[blueRing])%SPINDbMaxBuckets;
00146     if(bBucket<0) bBucket+=SPINDbMaxBuckets; 
00147 
00148     int yBucket=(bx*3+mTabSpinV124->bucketOffset[yellRing])%SPINDbMaxBuckets;
00149 
00150     //...... find 4 spin bits for each ring
00151     int yNib=mTabSpinV124->v124bits[yBucket]&0x0f;
00152     int bNib=mTabSpinV124->v124bits[bBucket]>>4;
00153 
00154     int spin8=(bNib<<4) + yNib;
00155     spin8bits[bx]=spin8;
00156     //...... map 8spin bits to 4spin bits 
00157     int spin4 =-1;
00158     if( (yNib==nibZ && bNib==nibZ) ||  (yNib==nibE && bNib==nibE) )
00159       spin4=0;
00160     else if ( yNib==nibE && bNib==nibP )  spin4=4;
00161     else if ( yNib==nibE && bNib==nibN )  spin4=8;
00162     else if ( yNib==nibP && bNib==nibE )  spin4=1;
00163     else if ( yNib==nibP && bNib==nibP )  spin4=5;
00164     else if ( yNib==nibN && bNib==nibP )  spin4=6;
00165     else if ( yNib==nibN && bNib==nibE )  spin4=2;
00166     else if ( yNib==nibP && bNib==nibN )  spin4=9;
00167     else if ( yNib==nibN && bNib==nibN )  spin4=10;
00168     // if(spin4>=0)  printf("bx=%3d bucket: B%03d Y%03d spin8=%3d spin4=%d\n",bx,bBucket,yBucket,bNib<<4+yNib,spin4);
00169     spin4bits[bx]=spin4;
00170     //.......just count types of bXings
00171     switch(spin4) {
00172     case 0: nP0++; break;
00173     case 1: 
00174     case 2: 
00175     case 4: 
00176     case 8: 
00177       nP1++; break;
00178     case 5: 
00179     case 6: 
00180     case 9: 
00181     case 10: 
00182       nP2++; break;
00183     default:
00184       nPer++;
00185     }
00186     //  printf("bx=%4d  b=%4d y=%4d  bNib=x%x yNib=x%x  spin8=x%2x spin4=%2d\n",bx,bBucket/3, yBucket/3,bNib,yNib,spin8,spin4); 
00187 
00188   } 
00189 
00190   char *polDir="scrambled";
00191   if(isPolDirTrans()) polDir="Transverse";
00192   if(isPolDirLong()) polDir="Longitudinal";
00193   
00194   LOG_INFO<< GetName()<<"::InitRun mOptimized() "<<
00195     " nFillBunch blue="<<numberOfFilledBunchesBlue()<<" yellow="<<numberOfFilledBunchesYellow()<<",  CAD pol pattern="<<mCADpolPattern<<
00196      "\n        polDir="<<polDir<<
00197      "  bXing w/ pol2="<<nP2<<" pol1="<<nP1<<" unPol="<<nP0<<" errPol="<<nPer<<endm; 
00198   return;
00199 } 
00200 
00201 
00202 //_________________________________________________________
00203 //_________________________________________________________
00204 //_________________________________________________________
00205 
00206 Int_t StSpinDbMaker::Make(){
00207   
00208   //  printf("\n\nMake :::::: %s\n\n\n",GetName());
00209 
00210   return kStOK;
00211 
00212 }
00213 
00214 //_________________________________________________________
00215 //_________________________________________________________
00216 //_________________________________________________________
00217 
00218 template <class St_T, class T_st> void 
00219 StSpinDbMaker::getTable(TDataSet *mydb,  TString tabName,   T_st** outTab ){
00220 
00221   *outTab=0;
00222   //  printf("\n\n%s::TTT --> %s, size=%d\n",GetName(),tabName.Data(),sizeof(T_st));
00223 
00224   char name[1000];
00225   sprintf(name,"%s",tabName.Data());
00226   
00227   gMessMgr->Message("","D") << GetName()<<"::InitRun  request="<< name <<endm;
00228 
00229   St_T *ds= (St_T *)mydb->Find(name);
00230   if(ds==0) {
00231     gMessMgr->Message("","W") << GetName()<<"::InitRun   table='"<< name <<"' not Found in DB, continue "<<endm;
00232     return ;
00233   }
00234 
00235   if(ds->GetNRows()!=1) {
00236     gMessMgr->Message("","W") << GetName()<<"::InitRun  table='"<< name <<"' no records, continue "<<endm; 
00237     return ;
00238   }
00239   
00240   *outTab=(T_st *) ds->GetArray();
00241 
00242   if(*outTab==0) {
00243     LOG_WARN<<" GetArray() failed"<<endm;
00244     return  ;
00245   }
00246 
00247   mNFound++;
00248   gMessMgr->Message("","I") << GetName()<<"::table '"<< name <<"': "<<(*outTab)->comment<<endm; 
00249 
00250   return ; // copy the whole s-struct to allow flavor change;
00251 
00252 }
00253 
00254 
00255 //--------------------------------------------------
00256 //--------------------------------------------------
00257 bool
00258 StSpinDbMaker::isPolDir(spinDbEnum polDir){
00259   if(!mTabSpinV124) return false;
00260   int i;  
00261   //  for(i=0;i<SPINDbMaxRing;i++) printf("rot(%d)=%d\n",i,mTabSpinV124->rotatorState[i]);
00262   
00263   for(i=0;i<SPINDbMaxRing;i++)
00264     if(mTabSpinV124->rotatorState[i]!=polDir) return false;
00265   return  true;
00266 }
00267 
00268 //--------------------------------------------------
00269 //--------------------------------------------------
00270 int
00271 StSpinDbMaker:: spin4usingBX48(int bx48){
00272   if(!isValid()) return -1;
00273   if(bx48<0 || bx48>=SPINDbMaxBXings) return -1;
00274   int bx=(bx48+mTabSpinStar->bXoff48)%SPINDbMaxBXings;
00275   // printf("inspin4..., bx48=%d bx=%d\n",bx48,bx);
00276   return spin4bits[bx];
00277 }
00278 
00279 //--------------------------------------------------
00280 //--------------------------------------------------
00281 int
00282 StSpinDbMaker:: spin4usingBX7(int bx7){
00283   if(!isValid()) return -1;
00284   if(bx7<0 || bx7>=SPINDbMaxBXings) return -1;
00285   int bx=(bx7+mTabSpinStar->bXoff7)%SPINDbMaxBXings;
00286   return spin4bits[bx];
00287 }
00288 
00289 //--------------------------------------------------
00290 //--------------------------------------------------
00291 int
00292 StSpinDbMaker::spin8usingBX48(int bx48){
00293   if(!isValid()) return -1;
00294   if(bx48<0 || bx48>=SPINDbMaxBXings) return -1;
00295   int bx=(bx48+mTabSpinStar->bXoff48)%SPINDbMaxBXings;
00296   return spin8bits[bx];
00297 }
00298 
00299 //--------------------------------------------------
00300 //--------------------------------------------------
00301 int
00302 StSpinDbMaker:: spin8usingBX7(int bx7){
00303   if(!isValid()) return -1;
00304   if(bx7<0 || bx7>=SPINDbMaxBXings) return -1;
00305   int bx=(bx7+mTabSpinStar->bXoff7)%SPINDbMaxBXings;
00306   return spin8bits[bx];
00307 }
00308 
00309 //--------------------------------------------------
00310 //--------------------------------------------------
00311 int
00312 StSpinDbMaker::BX48offset(){
00313   if(!isValid()) return -1;
00314   return mTabSpinStar->bXoff48;
00315 }
00316 
00317 //--------------------------------------------------
00318 //--------------------------------------------------
00319 bool
00320 StSpinDbMaker::isBXfilledUsingBX48(int bx48){
00321   if(!isValid()) return false;
00322   if(bx48<0 || bx48>=SPINDbMaxBXings) return false;
00323   int bx=(bx48+mTabSpinStar->bXoff48)%SPINDbMaxBXings;
00324   return  ((spin8bits[bx] & 0x11)==0x11);
00325 }
00326 
00327 
00328 //--------------------------------------------------
00329 //--------------------------------------------------
00330 bool
00331 StSpinDbMaker::isBXfilledUsingInternalBX(int bx){
00332   if(!isValid()) return false;
00333   if(bx<0 || bx>=SPINDbMaxBXings) return false;
00334   return  ((spin8bits[bx] & 0x11)==0x11);
00335 }
00336 
00337 
00338 //--------------------------------------------------
00339 //--------------------------------------------------
00340 int
00341 StSpinDbMaker::BXyellowUsingBX48(int bx48){
00342   if(!isValid()) return -1;
00343   if(bx48<0 || bx48>=SPINDbMaxBXings) return -1;
00344   return (bx48+mTabSpinStar->bXoff48)%SPINDbMaxBXings;
00345 }
00346 
00347 //--------------------------------------------------
00348 //--------------------------------------------------
00349 int
00350 StSpinDbMaker::BXstarUsingBX48(int bx48){
00351   if(!isValid()) return -1;
00352   if(bx48<0 || bx48>=SPINDbMaxBXings) return -1;
00353   return (bx48+mTabSpinStar->bXoff48)%SPINDbMaxBXings;
00354 }
00355 
00356 
00357 //--------------------------------------------------
00358 //--------------------------------------------------
00359 bool
00360 StSpinDbMaker:: isMaskedUsingBX48(int bx48){
00361   if(!isValid()) return true;
00362   if(bx48<0 || bx48>=SPINDbMaxBXings) return true;
00363   int bxStar= BXstarUsingBX48(bx48);
00364   return mTabSpinBXmask->bXmask[bxStar];
00365 } 
00366 
00367 
00368 //--------------------------------------------------
00369 //--------------------------------------------------
00370 int
00371 StSpinDbMaker::offsetBX48minusBX7(int bx48, int bx7){
00372   if(!isValid()) return -1;
00373   int bxa=BXstarUsingBX48(bx48);
00374   int bxb=BXstarUsingBX7(bx7);
00375   if(bxa<0 || bxb<0) return -1;
00376   int diff=bxa-bxb;
00377   if(diff<0) diff+=SPINDbMaxBXings;
00378   return diff;
00379 }
00380 
00381 //--------------------------------------------------
00382 //--------------------------------------------------
00383 bool
00384 StSpinDbMaker::isBXfilledUsingBXyellow(int bxStar){
00385   if(!isValid()) return false;
00386   if(bxStar<0 || bxStar>=SPINDbMaxBXings) return false;
00387    return  ((spin8bits[bxStar] & 0x11)==0x11);
00388 }
00389 
00390 
00391 //--------------------------------------------------
00392 //--------------------------------------------------
00393 bool
00394 StSpinDbMaker::isBXmaskedUsingBXyellow(int bxStar){
00395   if(!isValid()) return true;
00396   if(bxStar<0 || bxStar>=SPINDbMaxBXings) return true;
00397    return mTabSpinBXmask->bXmask[bxStar];
00398 }
00399 
00400 //--------------------------------------------------
00401 //--------------------------------------------------
00402 // EXPERT ONLY METHODS ....
00403 //--------------------------------------------------
00404 //--------------------------------------------------
00405 
00406 
00407 //--------------------------------------------------
00408 //--------------------------------------------------
00409 const unsigned char *
00410 StSpinDbMaker::getRawV124bits(){
00411   return mTabSpinV124->v124bits;
00412 }
00413 
00414 //--------------------------------------------------
00415 //--------------------------------------------------
00416 const int *
00417 StSpinDbMaker::getBucketOffsets(){
00418   return mTabSpinV124->bucketOffset;
00419 }
00420 
00421 //--------------------------------------------------
00422 //--------------------------------------------------
00423 const int *
00424 StSpinDbMaker::getSpin8bits(){
00425   return spin8bits;
00426 }
00427 
00428 
00429 //--------------------------------------------------
00430 //--------------------------------------------------
00431 int
00432 StSpinDbMaker::BX7offset(){
00433   if(!isValid()) return -1;
00434   return mTabSpinStar->bXoff7;
00435 }
00436 
00437 
00438 //--------------------------------------------------
00439 //--------------------------------------------------
00440 int
00441 StSpinDbMaker::BXyellowUsingBX7(int bx7){
00442   if(!isValid() ) return -1;
00443   if(bx7<0 || bx7>=SPINDbMaxBXings) return -1;
00444   return (bx7+mTabSpinStar->bXoff7)%SPINDbMaxBXings;
00445 }
00446 
00447 //--------------------------------------------------
00448 //--------------------------------------------------
00449 int
00450 StSpinDbMaker::BXstarUsingBX7(int bx7){
00451   if(!isValid() ) return -1;
00452   if(bx7<0 || bx7>=SPINDbMaxBXings) return -1;
00453   return (bx7+mTabSpinStar->bXoff7)%SPINDbMaxBXings;
00454 }
00455 
00456 
00457 //--------------------------------------------------
00458 //--------------------------------------------------
00459 const char* StSpinDbMaker::getV124comment(){ 
00460    return mTabSpinV124->comment;}
00461 
00462 //--------------------------------------------------
00463 //--------------------------------------------------
00464 void StSpinDbMaker::print(int level) {
00465 
00466   printf("SpinDb::print(level=%d) ...isValid=%d \n",level,isValid());
00467   if(!isValid()) {
00468     printf("       SpinDb not loaded or some tables not found, nFound=%d \n spinDB will not work if InitRun() was executed !!!\n\n",mNFound);
00469     return;
00470   }
00471 
00472   printf("Dump spinDB: valid=%d polTrans=%d polLong=%d BX7off=%d BX48off=%d\n", isValid(), isPolDirTrans(), isPolDirLong(), BX7offset(), BX48offset());
00473 
00474   printf("     spinDB: timeBucket offset: Blue=%d Yell=%d\n",getBucketOffsets()[blueRing],getBucketOffsets()[yellRing]);
00475  printf("     spinDB: bXing offset: off7=%d off48=%d\n",mTabSpinStar->bXoff7,mTabSpinStar->bXoff48);
00476 
00477   printf("DB records labels:\n V124: %s \n BXoffset: %s\n BXmask: %s\n\n",mTabSpinV124->comment,mTabSpinStar->comment,mTabSpinBXmask->comment); 
00478   printf("dump of spin bits  @ STAR IP, for 120 bXings, range [0,119]\n");
00479   int bx;
00480 
00481   printf("bXstar  spin8  spin4(dec) filled?  masked?  bx48   blueBx yellBx\n");
00482 
00483   for(bx=SPINDbMaxBXings-BX48offset();bx<2*SPINDbMaxBXings-BX48offset();bx++) {
00484     int bx48=bx%SPINDbMaxBXings;// this is dangerous, but works right
00485     int bXstar=BXstarUsingBX48(bx48);
00486     int blueBx=(bXstar+getBucketOffsets()[blueRing]/3)%SPINDbMaxBXings;
00487     int yellBx=(bXstar+getBucketOffsets()[yellRing]/3)%SPINDbMaxBXings;
00488     int spin8=spin8usingBX48(bx48);
00489     int spin4=spin4usingBX48(bx48);
00490     char *ftt="empty ";
00491     if (isBXfilledUsingBX48(bx48))ftt="filled";
00492     char *mtt="use "; 
00493     if(isMaskedUsingBX48(bx48))mtt="*mask*";
00494      printf("  %3d    0x%02x       %2d    %6s   %6s   %3d     %3d    %3d\n",bXstar,spin8,spin4,ftt,mtt,bx48,blueBx,yellBx);
00495     //  printf("bx48=%d mU=%d bxStar=%d mR=%d\n", bx48,isMaskedUsingBX48(bx48),bXstar,mTabSpinBXmask->bXmask[bXstar]);
00496     //  printf(" \n");    assert(1==2);
00497   }
00498   
00499   if(level<=0) return;
00500   int j;
00501   printf("dump raw V124 spin bits:\n time bucket, spin8(hex)\n");
00502   for(j=0;j<SPINDbMaxBuckets;j++) 
00503    printf("timeBucket=%3d rawV124=0x%x\n",j,getRawV124bits()[j]);
00504 
00505   printf("dump raw bXing mask \n STAR bXing mask (0=use, none-0=drop)\n");
00506   for(j=0;j<SPINDbMaxBXings;j++) 
00507    printf("%3d  %d\n",j,mTabSpinBXmask->bXmask[j]);
00508 }
00509 
00510 //--------------------------------------------------
00511 //--------------------------------------------------
00512 int 
00513 StSpinDbMaker::numberOfFilledBunches(enum spinDbEnum iby) {
00514   if(!isValid()) return -1;
00515   return mNfilledBunches[iby];
00516 }
00517 
00518 //--------------------------------------------------
00519 //--------------------------------------------------
00520 void
00521 StSpinDbMaker::auxilairyVariables(){
00522   int sumF[SPINDbMaxRing]={0,0};
00523   TString patt[SPINDbMaxRing];
00524 
00525   int iby;
00526   int i;
00527   for (i=0;i<SPINDbMaxBXings;i++ ) {// loop over all 120 potential bunches
00528     int nib=0;
00529     for(iby=0;iby<SPINDbMaxRing;iby++) {
00530       switch(iby) {
00531       case blueRing: nib=mTabSpinV124->v124bits[i*3]>>4;   break;
00532       case yellRing: nib=mTabSpinV124->v124bits[i*3]&0x0f; break;
00533       default: assert(1==2); // logical error
00534       }
00535       if (! nib&0x01) continue; // skip not filled bunch
00536       sumF[iby]++;
00537       
00538       int bits=nib>>1; // drop the fill-bit
00539       switch (bits) {
00540       case 0x01: patt[iby]+="+"; break;
00541       case 0x02: patt[iby]+="-"; break;
00542       case 0x04: patt[iby]+="0"; break;
00543       default:  patt[iby]+="?"; 
00544       }
00545     } // end of Blue/yell
00546     
00547   }// end of bunches
00548  
00549 
00550   for(i=0;i<SPINDbMaxRing;i++) mNfilledBunches[i]=sumF[i];
00551      
00552   // assign poll pattern according to CAD convention
00553   int year=mDbDate/10000;
00554   mCADpolPattern=""; mCADpolPattern+=year;  mCADpolPattern+="_";
00555 
00556   switch(year) {
00557   case 2005: 
00558     if(patt[blueRing].BeginsWith("+-+-") && patt[yellRing].BeginsWith("++--"))
00559       { mCADpolPattern+="p1"; break; }
00560     if(patt[blueRing].BeginsWith("-+-+") && patt[yellRing].BeginsWith("++--"))
00561       { mCADpolPattern+="p2"; break; }
00562     if(patt[blueRing].BeginsWith("+-+-") && patt[yellRing].BeginsWith("--++"))
00563       { mCADpolPattern+="p3"; break; }
00564     if(patt[blueRing].BeginsWith("-+-+") && patt[yellRing].BeginsWith("--++"))
00565       { mCADpolPattern+="p4"; break; }
00566   default:
00567     mCADpolPattern+="noLabel";
00568   }
00569 
00570   LOG_DEBUG << GetName()<<"::auxilairyVariables()" <<
00571   Form(" dbDate=%d, CADpattern=%s\n   Blue=%s\n   Yell=%s, \n", mDbDate,mCADpolPattern.Data(),  patt[blueRing].Data(),  patt[yellRing].Data())<<endm;
00572 
00573 }
00574 
00575 
00576 // $Log: StSpinDbMaker.cxx,v $
00577 // Revision 1.14  2009/10/03 03:16:26  balewski
00578 // fix of swap between spin4= 8 & 2
00579 //
00580 // Revision 1.13  2009/09/26 20:34:50  balewski
00581 // additional methods added for 2009 data processing,
00582 // since allignment of STAR bXing changed from yellow beam (2005) to blue (2009) the names of some methods were adjusted
00583 //
00584 // Revision 1.12  2007/05/30 02:38:54  balewski
00585 // replace printf -->LOG_XXX
00586 //
00587 // Revision 1.11  2006/10/24 20:19:37  balewski
00588 // cleanup: - spin4 for abort gaps, drop STARbXing
00589 //
00590 // Revision 1.10  2006/01/05 18:21:24  balewski
00591 // added get: cadPollPatt, nFillBunch
00592 // changed BXstar --> BXyellow
00593 //
00594 // Revision 1.9  2006/01/03 22:12:51  balewski
00595 // 2 missing BX7 methods added
00596 //
00597 // Revision 1.8  2006/01/03 15:21:22  balewski
00598 // more printouts
00599 //
00600 // Revision 1.7  2005/12/16 17:40:08  balewski
00601 // more printout
00602 //
00603 // Revision 1.6  2005/11/04 18:56:07  balewski
00604 // cleanup of printouts
00605 //
00606 // Revision 1.5  2005/10/06 16:36:32  balewski
00607 // protection against printing not initialized DB content
00608 //
00609 // Revision 1.4  2005/10/05 13:41:47  balewski
00610 // more get-methods
00611 //
00612 // Revision 1.3  2005/10/04 18:47:38  balewski
00613 // cleanup
00614 //
00615 // Revision 1.2  2005/10/03 20:40:17  balewski
00616 // clenup
00617 //
00618 // Revision 1.1  2005/09/30 23:47:45  balewski
00619 // start
00620 //