Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Related Pages

SCTDdcRequest.cxx

00001 
00002 // This file contains definition of functions to produce 
00003 // DAQ request for DCS data single read (this is the DDC package DdcRequest class modified for SCT DAQ needs)
00004 //                  
00005 //  Created 21.05.2003
00006 //  by A. Abdesselam
00008 
00009 #include    <string>
00010 #include    <vector>
00011 #include    <algorithm>
00012 
00013 #include <ipc/partition.h>
00014 //IS stuff
00015 #include <is/isinfoany.h>
00016 #include <is/isnamedinfo.h>
00017 #include <unistd.h> // for usleep
00018 
00019 using namespace std;
00020 
00021 #include "sctddc/SCTDdcRequest.hxx" // includes ddc/DdcData.hxx which it probably picks up from /usr/local/atlas/tdaq/cmt/online-00-21-02/installed/include/ddc/DdcData.hxx which should define DDC_DAQ_REQUEST except that it doesn't, whereas /home/abdessel/DDC3/ddc/ddc-03-04-04/src/DdcData.hxx does ...
00022 
00023 SCTDdcRequest::SCTDdcRequest(IPCPartition& partition, string& isServer)
00024     : m_requestReady(false), m_partition(partition), m_requestServer(isServer)
00025 { 
00026   m_infoReceiver = new ISInfoReceiver(partition);
00027 }
00028 
00029 // initilizations related to request vector of float
00030 void SCTDdcRequest::requestReady_vec_init(unsigned int vecSize)
00031   {
00032     //reset the current index
00033     m_requestReady_vec_index = 0;
00034     //erase all previous if any (pehaps from previous call)
00035     m_requestReady_vec.erase(m_requestReady_vec.begin(), m_requestReady_vec.end());
00036     //initialize the vector to false 
00037     for(unsigned int i=0; i<vecSize; i++) 
00038       m_requestReady_vec.push_back(false);
00039     //initialise the local map (pehaps from previous call)
00040     m_floatVecRequestResponse.erase(m_floatVecRequestResponse.begin(), 
00041                     m_floatVecRequestResponse.end());
00042   }
00043 
00044 //test if all the responses came
00045 bool SCTDdcRequest::getRequestReady_vec()
00046   {
00047     bool allRequestReady = true;
00048     for(unsigned int i=0; i<m_requestReady_vec.size(); i++) 
00049       allRequestReady = allRequestReady && m_requestReady_vec[i];
00050     return  allRequestReady;
00051   }
00052 
00053 //tell that one response came:  request =true
00054 void SCTDdcRequest::setRequestReady_vec(bool request)
00055   {
00056     m_requestReady_vec[m_requestReady_vec_index] = request;
00057     m_requestReady_vec_index++;
00058   }
00059 //---------------------------------------------------------------------------------------------------------
00060 void requestCallback(ISCallbackInfo* isCallback)
00061 //---------------------------------------------------------------------------------------------------------
00062 {
00063   std::string value_str;
00064   OWLDate value_date;
00065   OWLTime value_time;
00066   //get the calling object (to modify its attributes)
00067   SCTDdcRequest* sctDdcRequest = (SCTDdcRequest*)(isCallback->parameter());
00068 
00069   //define ISInfoAny, we don't know appriori the type of the object in the IS
00070   ISInfoAny dcsData;
00071   if(isCallback->reason() != ISInfoDeleted) 
00072     {
00073       string dpeName = isCallback->name();
00074       isCallback->value(dcsData);
00075     }
00076   // usaly the number of attribute is 2: time and value
00077   int N = dcsData.countAttributes( );
00078   
00079   //cout << "=============== type = " << dcsData.getType() << std::endl;
00080   for (int i=0; i<N; i++)
00081     {
00082       switch(dcsData.getAttributeType())
00083     {
00084     case ISType::Boolean:
00085       //bool
00086       bool value_bool;
00087       dcsData >> value_bool;
00088       sctDdcRequest->setIntRequestResponse(int(value_bool));
00089       sctDdcRequest->setFloatRequestResponse(float(value_bool));//just for protection
00090       sctDdcRequest->setRequestReady(true);
00091       break;
00092     case ISType::S8:
00093     case ISType::U8:
00094     case ISType::S16:
00095       //short
00096       short value_s;
00097       dcsData >> value_s;
00098       sctDdcRequest->setIntRequestResponse(int(value_s));
00099       sctDdcRequest->setFloatRequestResponse(float(value_s));//just for protection
00100       sctDdcRequest->setRequestReady(true);
00101       break;
00102     case ISType::U16:
00103       //unsigned short
00104       unsigned short value_us;
00105       dcsData >> value_us;
00106       sctDdcRequest->setIntRequestResponse(int(value_us));
00107       sctDdcRequest->setFloatRequestResponse(float(value_us));//just for protection
00108       sctDdcRequest->setRequestReady(true);
00109       break;
00110     case ISType::S32:
00111       //long
00112       long value_int;
00113       dcsData >> value_int;
00114       sctDdcRequest->setIntRequestResponse(value_int);
00115       sctDdcRequest->setFloatRequestResponse(float(value_int));//just for protection
00116       sctDdcRequest->setRequestReady(true);
00117       break;
00118     case ISType::U32:
00119       //unsigned lon
00120       unsigned long value_uint;
00121       dcsData >> value_uint;
00122       sctDdcRequest->setIntRequestResponse(value_uint);
00123       sctDdcRequest->setFloatRequestResponse(float(value_uint));//just for protection
00124       sctDdcRequest->setRequestReady(true);
00125       break;
00126     case ISType::Float:
00127       //float
00128       float value_float;
00129       dcsData >> value_float;
00130       sctDdcRequest->setFloatRequestResponse(value_float);
00131       sctDdcRequest->setIntRequestResponse(int(value_float));//just for protection
00132       sctDdcRequest->setRequestReady(true);
00133       break;
00134     case ISType::Double:
00135       //double
00136       double value_d;
00137       dcsData >> value_d;
00138       sctDdcRequest->setFloatRequestResponse(float(value_d));
00139       sctDdcRequest->setIntRequestResponse(int(value_d));//just for protection
00140       sctDdcRequest->setRequestReady(true);
00141       break;
00142     case ISType::String:
00143       //std::string
00144       dcsData >> value_str;
00145       sctDdcRequest->setStringRequestResponse(value_str);
00146       sctDdcRequest->setRequestReady(true);
00147       break;
00148 
00149     case ISType::Date:
00150       //OWLDate
00151       dcsData >> value_date;
00152       std::cerr<<"SCTDdcRequest::requestCallback() DDC_ERROR: variable from dcs is date, "
00153            <<"not implemented inddcRequest class"<< std::endl;
00154       break;
00155     case ISType::Time:
00156       //OWLTine
00157       dcsData >> value_time;
00158       //cerr<<"DDC_ERROR: variable from dcs is time, "
00159       //    <<"not implemented inddcRequest class"<< endl;
00160       break;
00161       
00162       
00163     default:
00164       cout << "SCTDdcRequest::requestCallback() DDC_ERROR: Invalid Type" 
00165            << (long)dcsData.getAttributeType() << std::endl;
00166     }
00167     }
00168 }
00169 
00170 //---------------------------------------------------------------------------------------------------------
00171 void floatArrayRequestCallback(ISCallbackInfo* isCallback)
00172 //---------------------------------------------------------------------------------------------------------
00173 {
00174   OWLTime value_time;
00175   //get the calling object (to modify its attributes)
00176   SCTDdcRequest* sctDdcRequest = (SCTDdcRequest*)(isCallback->parameter());
00177 
00178   //define ISInfoAny, we don't know appriori the type of the object in the IS
00179   ISInfoAny dcsData;
00180   if(isCallback->reason() != ISInfoDeleted) 
00181     {
00182       string dpeName = isCallback->name();
00183       isCallback->value(dcsData);
00184     }
00185 
00186   //read the first item that is the time
00187   dcsData >> value_time;
00188 
00189   //read then the array of float
00190   float *float_array;
00191   size_t  array_size;
00192 
00193   dcsData.get(&float_array, array_size);
00194   sctDdcRequest->setFloatArrayRequestResponse(float_array, int(array_size));
00195   sctDdcRequest->setRequestReady(true);
00196   
00197   return;
00198 }
00199 
00200 //---------------------------------------------------------------------------------------------------------
00201 void requestFloatVecCallback(ISCallbackInfo* isCallback)
00202 //---------------------------------------------------------------------------------------------------------
00203 {
00204   std::string value_str;
00205   OWLDate value_date;
00206   OWLTime value_time;
00207   string dpeName;
00208 
00209   //get the calling object (to modify its attributes)
00210   SCTDdcRequest* sctDdcRequest = (SCTDdcRequest*)(isCallback->parameter());
00211 
00212   //define ISInfoAny, we don't know appriori the type of the object in the IS
00213   ISInfoAny dcsData;
00214   if(isCallback->reason() != ISInfoDeleted) 
00215     {
00216       dpeName = isCallback->name();
00217       //get the name of the prameter; the fromat of dpeName is: ISserve.path.parameter.Recv (.Send)
00218       unsigned int position = dpeName.find(".Recv");
00219       if(position != string::npos) dpeName = dpeName.substr(0,position);
00220       position = dpeName.find(".Send");
00221       if(position != string::npos) dpeName = dpeName.substr(0,position);
00222       dpeName = dpeName.substr(dpeName.find_last_of(".")+1, dpeName.size());
00223       isCallback->value(dcsData);
00224     }
00225   // usaly the number of attribute is 2: time and value
00226   int N = dcsData.countAttributes( );
00227   
00228   //cout << "    " << N << " attribute(s):" << std::endl;
00229   for (int i=0; i<N; i++)
00230     {
00231       switch(dcsData.getAttributeType())
00232     {
00233     case ISType::Boolean:
00234       //bool
00235       bool value_bool;
00236       dcsData >> value_bool;
00237       sctDdcRequest->setfloatVecRequestResponse(dpeName, float(value_bool));
00238       sctDdcRequest->setRequestReady_vec(true);
00239       break;
00240     case ISType::S8:
00241     case ISType::U8:
00242     case ISType::S16:
00243       //short
00244       short value_s;
00245       dcsData >> value_s;
00246       sctDdcRequest->setfloatVecRequestResponse(dpeName, float(value_s));
00247       sctDdcRequest->setRequestReady_vec(true);
00248       break;
00249     case ISType::U16:
00250       //unsigned short
00251       unsigned short value_us;
00252       dcsData >> value_us;
00253       sctDdcRequest->setfloatVecRequestResponse(dpeName, float(value_us));
00254       sctDdcRequest->setRequestReady_vec(true);
00255       break;
00256     case ISType::S32:
00257       //long
00258       long value_int;
00259       dcsData >> value_int;
00260       sctDdcRequest->setfloatVecRequestResponse(dpeName, float(value_int));
00261       sctDdcRequest->setRequestReady_vec(true);
00262       break;
00263     case ISType::U32:
00264       //unsigned lon
00265       unsigned long value_uint;
00266       dcsData >> value_uint;
00267       sctDdcRequest->setfloatVecRequestResponse(dpeName, float(value_uint));
00268       sctDdcRequest->setRequestReady_vec(true);
00269       break;
00270     case ISType::Float:
00271       //float
00272       float value_float;
00273       dcsData >> value_float;
00274       sctDdcRequest->setfloatVecRequestResponse(dpeName, value_float);
00275       sctDdcRequest->setRequestReady_vec(true);
00276       break;
00277     case ISType::Double:
00278       //double
00279       double value_d;
00280       dcsData >> value_d;
00281       sctDdcRequest->setfloatVecRequestResponse(dpeName, float(value_d));
00282       sctDdcRequest->setRequestReady_vec(true);
00283       break;
00284     case ISType::String:
00285       //std::string
00286       dcsData >> value_str;
00287       std::cerr
00288         <<"SCTDdcRequest::requestFloatVecCallback(..) DDC_ERROR: variable ("<<dpeName
00289            <<") is string, that is not supported in ddcRequest class"<< std::endl;
00290       break;
00291     case ISType::Date:
00292       //OWLDate
00293       dcsData >> value_date;
00294       std::cerr
00295         <<"SCTDdcRequest::requestFloatVecCallback(..) DDC_ERROR: variable ("<<dpeName
00296            <<") is date, that is not supported in ddcRequest class"<< std::endl;
00297       break;
00298     case ISType::Time:
00299       //OWLTine
00300       dcsData >> value_time;
00301       //cerr<<"DDC_ERROR: variable from dcs is time, "
00302       //    <<"not implemented inddcRequest class"<< endl;
00303       break;
00304       
00305     default:
00306       cout << "SCTDdcRequest::requestCallback() DDC_ERROR: Invalid Type" 
00307            << (long)dcsData.getAttributeType() << std::endl;
00308     }
00309     }
00310   //dcsData.reset();
00311 }
00312 
00313 //this method is to read int from DCS
00314 //---------------------------------------------------------------------------------------------------------
00315 void SCTDdcRequest::ddcSendRequest(string& dpeName, int& value, int timeout)
00316 //---------------------------------------------------------------------------------------------------------
00317 {
00318   
00319   ISInfo::Status rc;
00320   // IS server and PVSS DataPoint address
00321   string server_dpeName = m_requestServer + "." + dpeName;
00322 
00323   // first subscribe for the request repply 
00324   rc = m_infoReceiver->subscribe(server_dpeName.c_str(), requestCallback, (void*)this);
00325   if(rc != ISInfo::Success) 
00326     {
00327       cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: " << server_dpeName
00328        << " subscription fault " << rc << ". No IS server to send request" << endl;
00329     }
00330   
00331   time_t startRequestTime = time(&startRequestTime);
00332   // then send request
00333 
00334   //================================code from Slava
00335   ISInfo::Status exportResult = ISInfo::Success;
00336   string isObName;
00337   time_t currTime;
00338   
00339   isObName = m_requestServer + '.';
00340   isObName += DAQ_DATA_REQUEST;
00341   
00342   DcsSingleData<string>* ddcRequestForData 
00343     = new DcsSingleData<string>(time(&currTime), m_partition, (char*)isObName.c_str());
00344   ddcRequestForData->setValue(server_dpeName);
00345   exportResult = ddcRequestForData->checkin();
00346   if(exportResult == ISInfo::CommFailure) 
00347     {
00348       cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: " 
00349        << ctime((const time_t*)&currTime) << " IS server "
00350        << m_requestServer << " for DAQ's data requests in partition "
00351        << m_partition.name() << " does not run!" << endl;
00352     }
00353   //delete ddcRequestForData;
00354   //==================================end of code from Slava
00355   
00356   // wait for the request to be ready or the time to be out
00357   int deltaRequestTime = 0;
00358   while(!m_requestReady && deltaRequestTime< timeout)
00359     {
00360       usleep(10); // wait in micro seconds
00361       time_t timenow = time(&timenow);
00362       deltaRequestTime = timenow - startRequestTime;
00363     }
00364   // if time is out
00365   if(!m_requestReady)
00366     {
00367       cerr << "DDC_ERROR: request waiting time for "<<dpeName
00368        <<" is out!!, stupid value is returned!!"<<endl;
00369       m_infoReceiver->unsubscribe(server_dpeName.c_str());
00370       value = 9999999;
00371       delete ddcRequestForData;
00372       return;
00373     }
00374 
00375   //retune requested value
00376   value = m_intRequestResponse;
00377  //reset request to not ready (enable fro another request)
00378   m_requestReady = false;
00379 
00380   // Remove the request
00381   ddcRequestForData->remove();
00382   delete ddcRequestForData;
00383   m_infoReceiver->unsubscribe(server_dpeName.c_str());
00384 
00385 
00386   return;
00387 }
00388 
00389 //this method is to read array of float (dyn_Float) from DCS
00390 //---------------------------------------------------------------------------------------------------------
00391 void SCTDdcRequest::ddcSendRequest(string& dpeName, float* float_array, int& array_size, int timeout)
00392 //---------------------------------------------------------------------------------------------------------
00393 {
00394   
00395   ISInfo::Status rc;
00396   // IS server and PVSS DataPoint address
00397   string server_dpeName = m_requestServer + "." + dpeName;
00398 
00399   // first subscribe for the request repply 
00400   rc = m_infoReceiver->subscribe(server_dpeName.c_str(), 
00401                  floatArrayRequestCallback, (void*)this);
00402   if(rc != ISInfo::Success) 
00403     {
00404       cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: " << server_dpeName
00405        << " subscription fault " << rc << ". No IS server to send request" << endl;
00406     }
00407   
00408   time_t startRequestTime = time(&startRequestTime);
00409   // then send request
00410 
00411   //================================code from Slava
00412   ISInfo::Status exportResult = ISInfo::Success;
00413   string isObName;
00414   time_t currTime;
00415   
00416   isObName = m_requestServer + '.';
00417   isObName += DAQ_DATA_REQUEST;
00418   
00419   DcsSingleData<string>* ddcRequestForData 
00420     = new DcsSingleData<string>(time(&currTime), m_partition, (char*)isObName.c_str());
00421   ddcRequestForData->setValue(server_dpeName);
00422   exportResult = ddcRequestForData->checkin();
00423   if(exportResult == ISInfo::CommFailure) 
00424     {
00425       cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: " 
00426        << ctime((const time_t*)&currTime) << " IS server "
00427        << m_requestServer << " for DAQ's data requests in partition "
00428        << m_partition.name() << " does not run!" << endl;
00429     }
00430   //delete ddcRequestForData;
00431   //==================================end of code from Slava
00432   
00433   // wait for the request to be ready or the time to be out
00434   int deltaRequestTime = 0;
00435   while(!m_requestReady && deltaRequestTime< timeout)
00436     {
00437       usleep(10); // wait in micro seconds
00438       time_t timenow = time(&timenow);
00439       deltaRequestTime = timenow - startRequestTime;
00440     }
00441   // if time is out
00442   if(!m_requestReady)
00443     {
00444       cerr << "DDC_ERROR: request waiting time for "<<dpeName
00445        <<" is out!!, stupid value is returned!!"<<endl;
00446       m_infoReceiver->unsubscribe(server_dpeName.c_str());
00447       float_array = NULL;
00448       delete ddcRequestForData;
00449       return;
00450     }
00451 
00452   //retune requested array
00453   array_size = m_floatArraySizeRequestResponse;
00454   for(int i=0; i<array_size; i++)
00455     {
00456       float_array[i] = m_floatArrayRequestResponse[i];
00457     }
00458   //reset request to not ready (enable fro another request)
00459   m_requestReady = false;
00460 
00461   // Remove the request
00462   ddcRequestForData->remove();
00463   delete ddcRequestForData;
00464   m_infoReceiver->unsubscribe(server_dpeName.c_str());
00465 
00466   return;
00467 }
00468 
00469 //this method is to read float from DCS
00470 //---------------------------------------------------------------------------------------------------------
00471 void SCTDdcRequest::ddcSendRequest(string& dpeName, float& value, int timeout)
00472 //---------------------------------------------------------------------------------------------------------
00473 {
00474   
00475   ISInfo::Status rc;
00476   // IS server and PVSS DataPoint address
00477   string server_dpeName = m_requestServer + "." + dpeName;
00478 
00479   // first subscribe for the request repply 
00480   rc = m_infoReceiver->subscribe(server_dpeName.c_str(), requestCallback, (void*)this);
00481   if(rc != ISInfo::Success) 
00482     {
00483       cerr << "SCTDdcRequest::ddcSendRequest()  DDC_ERROR: " << server_dpeName
00484        << " subscription fault " << rc << ". No IS server to send request" << endl;
00485     }
00486   
00487   time_t startRequestTime = time(&startRequestTime);
00488   // then send request
00489 
00490   //==========code from Slava
00491   ISInfo::Status exportResult = ISInfo::Success;
00492   string isObName;
00493   time_t currTime;
00494   
00495   isObName = m_requestServer + '.';
00496   isObName += DAQ_DATA_REQUEST;
00497   
00498   DcsSingleData<string>* ddcRequestForData 
00499     = new DcsSingleData<string>(time(&currTime), m_partition, (char*)isObName.c_str());
00500   ddcRequestForData->setValue(server_dpeName);
00501   exportResult = ddcRequestForData->checkin();
00502   if(exportResult == ISInfo::CommFailure) {
00503     cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: " << ctime((const time_t*)&currTime) 
00504      << " IS server "
00505      << m_requestServer << " for DAQ's data requests in partition "
00506      << m_partition.name() << " does not run!" << endl;
00507   }
00508   //delete ddcRequestForData;
00509   //===========end of code from Slava
00510   
00511   // wait for the request to be ready or the time to be out
00512   int deltaRequestTime = 0;
00513   while(!m_requestReady && deltaRequestTime< timeout)
00514     {
00515       usleep(10); // wait in micro seconds
00516       time_t timenow = time(&timenow);
00517       deltaRequestTime = timenow - startRequestTime;
00518     }
00519   // if time is out
00520   if(!m_requestReady)
00521     {
00522       cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: request waiting time for "
00523        <<dpeName<<" is out!!"<<endl;
00524       m_infoReceiver->unsubscribe(server_dpeName.c_str());
00525       value = 9999999;
00526       delete ddcRequestForData;
00527       return;
00528     }
00529 
00530   //retune requested value
00531   value = m_floatRequestResponse;
00532  //reset request to not ready (enable fro another request)
00533   m_requestReady = false;
00534 
00535   // Remove the request
00536   ddcRequestForData->remove();
00537   delete ddcRequestForData;
00538   m_infoReceiver->unsubscribe(server_dpeName.c_str());
00539 
00540   return;
00541 }
00542 
00543 //this method is to read string from DCS
00544 //---------------------------------------------------------------------------------------------------------
00545 void SCTDdcRequest::ddcSendRequest(string& dpeName, string& value, int timeout)
00546 //---------------------------------------------------------------------------------------------------------
00547 {
00548   
00549   ISInfo::Status rc;
00550   // IS server and PVSS DataPoint address
00551   string server_dpeName = m_requestServer + "." + dpeName;
00552 
00553   // first subscribe for the request repply 
00554   rc = m_infoReceiver->subscribe(server_dpeName.c_str(), requestCallback, (void*)this);
00555   if(rc != ISInfo::Success) 
00556     {
00557       cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: " << server_dpeName
00558        << " subscription fault " << rc << ". No IS server to send request" << endl;
00559     }
00560   
00561   time_t startRequestTime = time(&startRequestTime);
00562   // then send request
00563 
00564   //==========code from Slava
00565   ISInfo::Status    exportResult = ISInfo::Success;
00566   string            isObName;
00567   time_t            currTime;
00568   
00569   isObName = m_requestServer + '.';
00570   isObName += DAQ_DATA_REQUEST;
00571   
00572   DcsSingleData<string>* ddcRequestForData 
00573     = new DcsSingleData<string>(time(&currTime), m_partition, (char*)isObName.c_str());
00574   ddcRequestForData->setValue(server_dpeName);
00575   exportResult = ddcRequestForData->checkin();
00576   if(exportResult == ISInfo::CommFailure) {
00577     cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: " 
00578      << ctime((const time_t*)&currTime) << " IS server "
00579      << m_requestServer << " for DAQ's data requests in partition "
00580      << m_partition.name() << " does not run!" << endl;
00581   }
00582   //delete ddcRequestForData;
00583   //==========end of code from Slava
00584   
00585   // wait for the request to be ready or the time to be out
00586   int deltaRequestTime = 0;
00587   while(!m_requestReady && deltaRequestTime< timeout)
00588     {
00589       usleep(10); // wait in micro seconds
00590       time_t timenow = time(&timenow);
00591       deltaRequestTime = timenow - startRequestTime;
00592     }
00593   // if time is out
00594   if(!m_requestReady)
00595     {
00596       cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: request waiting time for "
00597        <<dpeName<<" is out!!"<<endl;
00598       m_infoReceiver->unsubscribe(server_dpeName.c_str());
00599       value = 9999999;
00600       delete ddcRequestForData;
00601       return;
00602     }
00603 
00604   //retune requested value
00605   value = m_stringRequestResponse;
00606   //reset request to not ready (enable fro another request)
00607   m_requestReady = false;
00608 
00609   // Remove the request
00610   ddcRequestForData->remove();
00611   delete ddcRequestForData;
00612   m_infoReceiver->unsubscribe(server_dpeName.c_str());
00613 
00614   return;
00615 }
00616 
00617 //this method is to read several (vector) of float from DCS. Rq: intger are converted to float!
00618 //---------------------------------------------------------------------------------------------------------
00619 void SCTDdcRequest::ddcSendRequest(std::vector<string>& dpeName_vec, 
00620                    std::map<string, float>& values_map, int timeout)
00621 //---------------------------------------------------------------------------------------------------------
00622 {
00623   
00624   ISInfo::Status rc;
00625   //number of parameters (request) in the vector
00626   unsigned int numberOfRequest = dpeName_vec.size();
00627   // IS server and PVSS DataPoint address
00628   std::vector<string> server_dpeName;
00629   // first subscribe for the request repply for all the parameters (datapoint elements)
00630   for(unsigned int i_requ=0; i_requ<numberOfRequest; i_requ++)
00631     {
00632       //name for IS server must be of the form is_server.parameter_path
00633       server_dpeName.push_back(m_requestServer + "." + dpeName_vec[i_requ]);
00634       //subscribe
00635       rc = m_infoReceiver->subscribe(server_dpeName[i_requ].c_str(), requestFloatVecCallback, 
00636                      (void*)this);
00637       if(rc != ISInfo::Success) 
00638     {
00639       cerr << " SCTDdcRequest::ddcSendRequest() DDC_ERROR: " << server_dpeName[i_requ]
00640        << " subscription fault " << rc << ". No IS server to send request" << endl;
00641     }
00642     }
00643 
00644   // initilizations related to request vector of float
00645   requestReady_vec_init(numberOfRequest);
00646   //start sending request time
00647   time_t startRequestTime = time(&startRequestTime);
00648   // then send request
00649 
00650   //================================code from Slava
00651 
00652   ISInfo::Status exportResult = ISInfo::Success;
00653   string isObName;
00654   time_t currTime;
00655   
00656   isObName = m_requestServer + '.';
00657   isObName += DAQ_DATA_REQUEST;
00658   
00659   DcsDataArray<string>* ddcRequestForData 
00660     = new DcsDataArray<string>(time(&currTime), m_partition, (char*)isObName.c_str());
00661   for(unsigned int i_requ=0; i_requ<numberOfRequest; i_requ++)
00662     {
00663       ddcRequestForData->addValue(server_dpeName[i_requ]);
00664     } 
00665   
00666   exportResult = ddcRequestForData->checkin();
00667   
00668   if(exportResult == ISInfo::CommFailure) 
00669     {
00670       cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: " << ctime((const time_t*)&currTime) 
00671        << " IS server "
00672        << m_requestServer << " for DAQ's data requests in partition "
00673        << m_partition.name() << " does not run!" << endl;
00674     }
00675   //delete ddcRequestForData;
00676   //==================================end of code from Slava
00677   // wait for the request to be ready or the time to be out
00678   int deltaRequestTime = 0;
00679   while(!getRequestReady_vec() && deltaRequestTime< timeout)
00680     {
00681       usleep(10); // wait in micro seconds
00682       time_t timenow = time(&timenow);
00683       deltaRequestTime = timenow - startRequestTime;
00684     }
00685 
00686   // if time is out
00687   if(!getRequestReady_vec())
00688     {
00689       cerr << "SCTDdcRequest::ddcSendRequest() DDC_ERROR: request waiting time for vector"
00690        <<" of float is out, or may be just some of the requests didn't come!!"<<endl;
00691     }
00692 
00693   //retune requested value
00694   values_map = m_floatVecRequestResponse;
00695 
00696   // Remove the request
00697   ddcRequestForData->remove();
00698   delete ddcRequestForData;
00699 
00700   //unsubsribe
00701   for(unsigned int i_requ=0; i_requ<numberOfRequest; i_requ++)
00702     {
00703       //name for IS server must be of the form is_server.parameter_path
00704       string server_dpeName = m_requestServer + "." + dpeName_vec[i_requ];
00705       //unsubscribe
00706       m_infoReceiver->unsubscribe(server_dpeName.c_str());
00707     }
00708 
00709   return;
00710 }
00711 
00712 //---------------------------------------------------------------------------------------------------------
00713 void getCallback(ISCallbackInfo* isCallback)
00714 //---------------------------------------------------------------------------------------------------------
00715 {
00716   OWLTime value_time;
00717   //get the calling object (to modify its attributes)
00718   float *value = (float*)(isCallback->parameter());
00719 
00720   //define ISInfoAny, we don't know appriori the type of the object in the IS
00721   ISInfoAny dcsData;
00722 
00723   if(isCallback->reason() != ISInfoDeleted) 
00724     {
00725       isCallback->value(dcsData);
00726     }
00727  
00728   // usaly the number of attribute is 2: time and value
00729   int N = dcsData.countAttributes( );
00730 
00731   for ( int i = 0; i < N; i++ )
00732     {
00733       switch ( dcsData.getAttributeType() )
00734     {
00735     case ISType::Float:
00736       //float
00737       dcsData >> *value;
00738       break;
00739       
00740     case ISType::Time:
00741       //OWLTine
00742       dcsData >> value_time;
00743       break;
00744       
00745     default:
00746       cout << " SCTDdcRequest::getCallback() ERROR: Invalid Type" 
00747            << (long)dcsData.getAttributeType() << std::endl;
00748     }
00749     }
00750   return;
00751 }
00752 
00753 //---------------------------------------------------------------------------------------------------------
00754 void SCTDdcRequest::readFromIS(string dpeName, float& value)
00755 //---------------------------------------------------------------------------------------------------------
00756 {
00757   
00758   ISInfo::Status rc;
00759   // IS server and PVSS DataPoint address
00760   string server_dpeName = "DDC_DT." + dpeName;
00761 
00762   // first subscribe for the request repply 
00763   rc = m_infoReceiver->subscribe(server_dpeName.c_str(), getCallback, (void*)(&value));
00764   if(rc != ISInfo::Success) 
00765     {
00766       cerr << "SCTDdcRequest::readFromIS() DDC_ERROR: " << server_dpeName
00767            << " subscription fault " << rc << ". No IS server to send request" << endl;
00768     }
00769   return;
00770 }
00771 

Generated on Fri Sep 16 18:01:58 2005 for SCT DAQ/DCS Software - C++ by doxygen 1.3.5