/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Calibration/CalibSvc/CalibMySQLCnv/CalibMySQLCnv-00-01-09/src/CalibMySQLCnvSvc.cxx

Go to the documentation of this file.

// $Header: /bes/bes/BossCvs/Calibration/CalibSvc/CalibMySQLCnv/src/CalibMySQLCnvSvc.cxx,v 1.49 2013/05/22 07:57:53 maqm Exp $
#include <string>
#include <cstdio>
#include <stdexcept>

#include "CalibMySQLCnv/CalibMySQLCnvSvc.h"
#include "CalibDataSvc/ICalibRootSvc.h"   // for def. of CALIBROOT_StorageType
#include "CalibDataSvc/ICalibTreeSvc.h" 
#include "calibUtil/Metadata.h"
#include "GaudiKernel/IDataManagerSvc.h"

#include "CalibData/CalibBase.h"
#include "CalibData/CalibBase1.h"
//#include "CalibData/CalibTime.h"
#include "CalibData/CalibModelSvc.h"
#include "GaudiKernel/SmartDataPtr.h"

#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/GenericAddress.h"
#include "GaudiKernel/IConverter.h"
#include "GaudiKernel/IDetDataSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IOpaqueAddress.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IValidity.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/SvcFactory.h"
#include "TBuffer.h"
#include "TBufferFile.h"
#include "TTree.h"
#include "CalibMySQLCnv/TreeAddress.h"
#include "EventModel/EventModel.h"
#include "EventModel/EventHeader.h"
#include "DatabaseSvc/IDatabaseSvc.h"
#include "TROOT.h"
#include "TFile.h"
#include <iostream>

using namespace CalibData;
//static SvcFactory<CalibMySQLCnvSvc>          CalibMySQLCnvSvc_factory;
//const ISvcFactory& CalibMySQLCnvSvcFactory = CalibMySQLCnvSvc_factory;

// Local utility to translate calibration quality list to bit map
namespace {
        unsigned int toQualityMask(std::vector<std::string>& qualities) {
                using calibUtil::Metadata;

                unsigned int mask = 0;
                unsigned n = qualities.size();

                for (unsigned i = 0; i < n; i++) {
                        std::string iString = qualities[i];
                        if (iString.size() < 3) continue;
                        iString.resize(3);
                        if (iString == "PRO") mask |= Metadata::LEVELProd;
                        else if (iString =="DEV") mask |= Metadata::LEVELDev;
                        else if (iString =="TES") mask |= Metadata::LEVELTest;
                        else if (iString =="SUP") mask |= Metadata::LEVELSuperseded;
                }
                return mask;
        }
}

        CalibMySQLCnvSvc::CalibMySQLCnvSvc( const std::string& name, ISvcLocator* svc)
        : ConversionSvc (name, svc, MYSQL_StorageType)
                , m_meta(0), m_useEventTime(true),m_enterTimeStart(0), m_enterTimeEnd(0),
                m_qualityMask(0)
{
        // declareProperty("Host", m_host = "202.122.37.69");
        declareProperty("Host", m_host = "bes3db2.ihep.ac.cn");
        declareProperty("UseEventTime", m_useEventTime = true);
        declareProperty("EnterTimeEnd", m_enterTimeEndString = std::string("") );
        declareProperty("EnterTimeStart", m_enterTimeStartString = std::string("") );
        //  declareProperty("DbName", m_dbName = std::string("calib") );
        declareProperty("DbName", m_dbName = std::string("offlinedb") );
        declareProperty("QualityList", m_qualityList);
        declareProperty("CrashOnError", m_crash = true);
        declareProperty("Sft_Ver",sft_ver);
        declareProperty("Cal_Ver",cal_ver);
        declareProperty("MdcFlag",m_flag[0]="default");
        declareProperty("DeDxFlag",m_flag[1]="default");
        declareProperty("EmcFlag",m_flag[2]="default");
        declareProperty("TofFlag",m_flag[3]="default");
        declareProperty("MucFlag",m_flag[4]="default");
        declareProperty("EsTimeFlag",m_flag[5]="default");
        declareProperty("EstTofFlag",m_flag[6]="default");
        declareProperty("MdcAlignFlag",m_flag[7]="default");
        declareProperty("TofQElecFlag",m_flag[8]="default");
        declareProperty("TofSimPFlag",m_flag[9]="default");
        declareProperty("DedxSimFlag",m_flag[10]="default");
        declareProperty("MdcDataFlag",m_flag[11]="default");
        declareProperty("MdcCalPar",m_calPar[0]="default");
        declareProperty("DeDxCalPar",m_calPar[1]="default");
        declareProperty("EmcCalPar",m_calPar[2]="default");
        declareProperty("TofCalPar",m_calPar[3]="default"); 
        declareProperty("MucCalPar",m_calPar[4]="default");
        declareProperty("EsTimeCalPar",m_calPar[5]="default");
        declareProperty("EstTofCalPar",m_calPar[6]="default");
        declareProperty("MdcAlignPar",m_calPar[7]="default");
        declareProperty("TofQElecPar",m_calPar[8]="default");
        declareProperty("TofSimPar",m_calPar[9]="default");
        declareProperty("DedxSimPar",m_calPar[10]="default");
        declareProperty("MdcDataConstVer",m_calPar[11]="default");
        declareProperty("MdcBossVer",m_bossver[0]="default");
        declareProperty("DeDxBossVer",m_bossver[1]="default");
        declareProperty("EmcBossVer",m_bossver[2]="default");
        declareProperty("TofBossVer",m_bossver[3]="default");
        declareProperty("MucBossVer",m_bossver[4]="default");
        declareProperty("EsTimeBossVer",m_bossver[5]="default");
        declareProperty("EstTofBossVer",m_bossver[6]="default");
        declareProperty("MdcAlignBossVer",m_bossver[7]="default");
        declareProperty("TofQElecBossVer",m_bossver[8]="default");
        declareProperty("TofSimBossVer",m_bossver[9]="default");
        declareProperty("DedxSimBossVer",m_bossver[10]="default");
        declareProperty("MdcDataConstBossVer",m_bossver[11]="default");
        declareProperty("Align_RunNo",m_MdcAlign_No=8093);
        declareProperty("Db_Status",m_dbStatus="OK");
        declareProperty("BossRelease",m_bossRelease="default");
}

CalibMySQLCnvSvc::~CalibMySQLCnvSvc(){ }

StatusCode CalibMySQLCnvSvc::initialize()
{
        // Initialize base class
        StatusCode sc = ConversionSvc::initialize();
        if ( !sc.isSuccess() ) return sc;

        MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );
        log << MSG::INFO << "Specific initialization starting" << endreq;

        IDataProviderSvc* pCDS = 0;
        sc = serviceLocator()->getService ("CalibDataSvc",  IDataProviderSvc::interfaceID(), (IInterface*&)pCDS);

        if ( !sc.isSuccess() ) {
                log << MSG::ERROR << "Could not locate CalibDataSvc" << endreq;
                return sc;
        }

        sc = serviceLocator()->service("EventDataSvc", m_eventSvc, true);
        if (sc .isFailure() ) {
                log << MSG::ERROR << "Unable to find EventDataSvc " << endreq;
                return sc;
        }

        // Set the CalibDataSvc as data provider service
        sc = setDataProvider(pCDS);
        if ( !sc.isSuccess() ) {
                log << MSG::ERROR << "Could not set data provider" << endreq;
                return sc;
        }

        // Query the IAddressCreator interface of the detector persistency service

        sc = serviceLocator()->service 
                ("DetectorPersistencySvc", m_detPersSvc, true);
        if ( !sc.isSuccess() ) {
                log << MSG::ERROR 
                        << "Cannot locate IConversionSvc interface of DetectorPersistencySvc"
                        << endreq;
                return sc;
        } else {
                log << MSG::DEBUG 
                        << "Retrieved IConversionSvc interface of DetectorPersistencySvc"
                        << endreq;
        }

        IAddressCreator* iAddrCreator;
        sc = m_detPersSvc->queryInterface(IAddressCreator::interfaceID(),(void**) &iAddrCreator);
        //  sc = m_detPersSvc->queryInterface(IID_IAddressCreator,(void**) &iAddrCreator);
        if ( !sc.isSuccess() ) {
                log << MSG::ERROR << "Could not locate CalibDataSvc" << endreq;
                return sc;
        }

        sc = setAddressCreator(iAddrCreator);
        if ( !sc.isSuccess() ) {
                log << MSG::ERROR       << "Cannot set the address creator" << endreq;
                return sc;
        }

        // Get properties from the JobOptionsSvc
        sc = setProperties();
        if ( !sc.isSuccess() ) {
                log << MSG::ERROR << "Could not set jobOptions properties" << endreq;
                return sc;
        }
        log << MSG::DEBUG << "Properties were read from jobOptions" << endreq;

        // Translate list of calibration quality names to bit mask form used 
        // by calibUtil::Metadata::findBest     Defaults to PROD + DEV for now
        // (that was old fixed value)
        m_qualityMask = toQualityMask(m_qualityList);
        if (!m_qualityMask) {
                m_qualityMask = calibUtil::Metadata::LEVELProd |
                        calibUtil::Metadata::LEVELDev;
        }

        // Make a calibUtil::Metadata instance 
        // Conceivably, could start up a different conversion service, depending 
        // on job options parameters, which would look very much like this one
        // except for having a different way to access metadata.
        m_meta = new calibUtil::Metadata(m_host, "*", m_dbName);

        if (!m_meta) {
                log << MSG::ERROR << "Could not open connection to metadata dbs" << endreq;
                return MSG::ERROR;
        }
        // Probably should get this value from job options. 
        // Now we do.  See m_qualityMask, m_qualityList
        //  m_calibLevelMask = calibUtil::Metadata::LEVELProd + 
        //    calibUtil::Metadata::LEVELDev;

        log << MSG::INFO << "Specific initialization completed" << endreq;
        return sc;
}


StatusCode CalibMySQLCnvSvc::finalize()
{
        MsgStream log(msgSvc(), "CalibMySQLCnvSvc");
        log << MSG::DEBUG << "Finalizing" << endreq;
        delete m_meta;
        m_meta = 0;
        return ConversionSvc::finalize();
}


StatusCode CalibMySQLCnvSvc::queryInterface(const InterfaceID& riid, 
                void** ppvInterface)
{
        if ( IID_ICalibMetaCnvSvc == riid )  {
                // With the highest priority return the specific interface of this service
                *ppvInterface = (ICalibMetaCnvSvc*)this;
        } else  {
                // Interface is not directly available: try out a base class
                return ConversionSvc::queryInterface(riid, ppvInterface);
        }
        addRef();
        return StatusCode::SUCCESS;
}


StatusCode CalibMySQLCnvSvc::createObj (IOpaqueAddress* pAddress, 
                DataObject*&    refpObject ) {

        MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );


        // Create the object according to calib type, flavor, time, instrument, clid.
        // Notice that the CalibMySQLCnvSvc has no converters of its own:
        // object creation is delegated to another CnvSvc via a temporary address
        // The IOpaqueAddress specifies calibration type and specific flavor.
        // The secondary storage type is always discovered dynamically
        StatusCode sc;

        sc = createCalib(refpObject,
                        pAddress->par()[0],
                        pAddress->clID(),
                        pAddress->registry() );


        if ( !sc.isSuccess() ) {
                log << MSG::ERROR << "Could not create calib DataObject" << endreq;
        }
        log << MSG::DEBUG << "Method createObj exiting" << endreq;
        return sc;
}

StatusCode CalibMySQLCnvSvc::fillObjRefs(IOpaqueAddress* /*pAddress*/, 
                DataObject*     /*pObject */ ) {
        MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );
        return StatusCode::SUCCESS;
}


StatusCode CalibMySQLCnvSvc::updateObj(IOpaqueAddress* pAddress, 
                DataObject*     pObject  ) {

        //  using facilities::Timestamp;

        MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );

        // Don't update when we're using enter time
        log << MSG::DEBUG << "CalibMySQLCnvSvc::updateObj starting ...."<<endreq;

        if( 0 == pObject ) {
                log << MSG::ERROR << "There is no object to update" << endreq;
                return StatusCode::FAILURE;
        } 

        StatusCode sc = updateCalib(pObject, pAddress->par()[0], 
                        pAddress->clID(), pAddress->registry() );
        if ( !sc.isSuccess() ) {
                log << MSG::ERROR << "Could not update calib DataObject" << endreq;
                return sc;
        }

        return StatusCode::SUCCESS;  
}

StatusCode CalibMySQLCnvSvc::updateObjRefs (IOpaqueAddress* /*pAddress*/, 
                DataObject*     /*pObject */ ) {
        MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );
        return StatusCode::SUCCESS;
}


StatusCode CalibMySQLCnvSvc::createRep(DataObject* /*pObject*/,
                IOpaqueAddress*& /*refpAddress*/ ) {

        MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );
        // log << MSG::WARNING << "Method createRep is not implemented" << endreq;
        return StatusCode::SUCCESS;
}


StatusCode CalibMySQLCnvSvc::fillRepRefs (IOpaqueAddress* /*pAddress*/, 
                DataObject*     /*pObject */ ) {
        MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );
        //  log << MSG::WARNING << "Method fillRepRefs is not implemented" << endreq;
        return StatusCode::SUCCESS;
}


StatusCode CalibMySQLCnvSvc::updateRep (IOpaqueAddress* /*pAddress*/, 
                DataObject*     /*pObject */ ) {
        MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );
        // log << MSG::WARNING << "Method updateRep is not implemented" << endreq;
        return StatusCode::SUCCESS;
}


StatusCode CalibMySQLCnvSvc::updateRepRefs (IOpaqueAddress* /*pAddress*/, 
                DataObject*     /*pObject */ ) {
        MsgStream log(msgSvc(), "CalibMySQLCnvSvc");
        //log << MSG::WARNING << "Method updateRepRefs is not implemented" << endreq;
        return StatusCode::SUCCESS;
}

StatusCode CalibMySQLCnvSvc::createAddress(long svc_type,
                const CLID& clid,
                const std::string* par, 
                const unsigned long* /*ipar*/,
                IOpaqueAddress*& refpAddress ) {
        // First check that requested address is of type MYSQL_StorageType
        MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );
        if ( svc_type!= MYSQL_StorageType ) {
                log << MSG::ERROR 
                        << "Cannot create addresses of type " << (int)svc_type 
                        << " which is different from " << (int)MYSQL_StorageType 
                        << endreq;
                return StatusCode::FAILURE;
        }
        log << MSG::INFO
                << " create address in CalibMySQLCnvSvc "
                << endreq;

        refpAddress = new GenericAddress( MYSQL_StorageType, 
                        clid, 
                        par[0]);

        return StatusCode::SUCCESS;
}

//select sftver and parver frm table CalVtxLum
StatusCode CalibMySQLCnvSvc::getSftParVer(std::string& SftVer,
                std::string& CalParVer,
                int &runfrm,
                int &runto,
                int RunNo,
                std::string BossRelease,
                std::string DataType
                )
{
        using namespace rdbModel;
        MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );
        char stmt[300];
        int run_No =RunNo;
        MYSQL_RES *res_set;
        IDatabaseSvc* m_dbsvc;
        DatabaseRecordVector res;
        StatusCode sc=serviceLocator()->service("DatabaseSvc",m_dbsvc,true);
        if (sc .isFailure() ) {
                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                return sc;
        }

        const char* bossRelease = BossRelease.c_str();
        const char* dataType = DataType.c_str();

        sprintf(stmt,"select RunFrom,RunTo,SftVer,ParVer from CalVtxLumVer where BossRelease = '%s' and RunFrom <= %d and RunTo >= %d and DataType='%s' ",bossRelease,run_No,run_No,dataType);

        int row_no = m_dbsvc->query("offlinedb",stmt,res);
        if(row_no<1){
                std::cout<<"ERROR:error searching with:"<<stmt<<std::endl;
                exit(1);
        }
        if(row_no=1){
                DatabaseRecord* records1 = res[0];
    runfrm=records1->GetInt("RunFrom");
    runto=records1->GetInt("RunTo");
                //cout<<dataType<<" runfrm,runto in getSftParVer is:"<<runfrm<<"::::"<<runto<<endl;
                SftVer=records1->GetString("SftVer");
                CalParVer=records1->GetString("ParVer");
        }
        if(row_no>1){
                cout<<"ERROR: "<<dataType<<" set overlapped run number in the table CalVtxLumVer"<<endl;
                exit(1);
                }
        return StatusCode::SUCCESS;
}



StatusCode CalibMySQLCnvSvc::createCalib(DataObject*&       refpObject,
                const std::string& fullpath,
                const CLID&        classID,
                IRegistry*         entry)
{
        MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );

        // Look up calib object in the Metadata database
        std::string cType = CalibData::CalibModelSvc::getCalibType(fullpath);

        // ..and extra special munging for test
        if (std::string("Test") == cType.substr(0, 4)) {
                cType = std::string("Test_Gen");
        }

        std::string testfile = std::string(getenv("CALIBMYSQLCNVROOT"))+"/share/test.root";
        TFile *f1=new TFile(testfile.c_str(),"read");
        unsigned int ser = 0;
        //runfrm,runto are the value from the table ***CalConst;runfrm1,runto1 are the value from the table CalVtxLumVer
        int runfrm,runfrm1;
        int runto,runto1;
        std::string flag="default";
        calibUtil::Metadata::eRet ret;

        MSG::Level msgLevel =  MSG::DEBUG;

        std::string physFmt = "UNK";
        std::string fmtVersion;
        std::string dataIdent;

        // Get the runNo of current event:
        SmartDataPtr<Event::EventHeader> evt(m_eventSvc,"/Event/EventHeader");
        int runNo=0;
        if( !evt ){
                log << MSG::WARNING << "Unable to read the Event for TDS" << endreq;
                //         return StatusCode::FAILURE;
        }   
        if( evt ){
                if(cType!="TofCal"&&cType!="EstTofCal"&&cType!="TofSim"&&cType!="DedxSim") runNo = fabs(evt -> runNumber());
                if(cType=="TofCal"||cType=="EstTofCal"||cType=="TofSim"||cType=="DedxSim") runNo = evt -> runNumber();
        }
        DatabaseRecordVector res;

        StatusCode st1;

        //TofCalConst
        if((cType=="TofCal")&&(m_bossver[3]== "default" ))
        {
                std::string cType="Tof";
                if(m_bossRelease=="default")
                        {
                                log << MSG::FATAL << " Boss Release for TofCal not set!" << endreq;
                                exit(1);
                                
                        }
                else
                        {
                        st1=getSftParVer(m_bossver[3],m_calPar[3],runfrm1,runto1,runNo,m_bossRelease,cType);
                        //cout<<cType<<" runfrm1,runto1 is:"<<runfrm1<<"::"<<runto1<<endl;
                        if (st1 .isFailure() ) 
                        {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;                                                         
                        }
                        //cout<<"SftVer and CalParVer are:"<<sft_ver<<";"<<cal_ver<<endl;
                        ret = m_meta->getReadTOFInfo(ser,&runfrm,&runto,m_calPar[3],res,runNo,m_bossver[3]);

                }
        }
        else if ((cType=="TofCal")&&(m_bossver[3]!= "default" ))
        {
    m_flag[3]="set";
                flag=m_flag[3];
                //cout<<"flag @create Tof is:"<<m_flag[3]<<endl;
                ret = m_meta->getReadTOFInfo(ser,&runfrm,&runto,m_calPar[3],res,runNo,m_bossver[3]);
        }


        //EmcCalConst
        if((cType=="EmcCal")&&(m_bossver[2]== "default" ))   
        { 
                std::string cType="Emc";
                if(m_bossRelease=="default") 
                {
                        log << MSG::FATAL << " Boss Release for EmcCal not set!" << endreq;
                        exit(1);
                }
                else{

                        st1=getSftParVer(m_bossver[2],m_calPar[2],runfrm1,runto1,runNo,m_bossRelease,cType);
                        //cout<<cType<<" runfrm1,runto1 is:"<<runfrm1<<"::"<<runto1<<endl;
                        //cout<<"flag @create Emc is:"<<flag<<endl;
                        if (st1 .isFailure() ) 
                        {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1; 
                        }
                        ret = m_meta->getReadEMCInfo(ser,&runfrm,&runto, m_calPar[2], res,runNo,m_bossver[2]);                    
                }
        }
        else if((cType=="EmcCal")&&(m_bossver[2]!= "default" ))
        {
                m_flag[2]="set";
                flag=m_flag[2];
    //cout<<"flag @create Emc is:"<<m_flag[2]<<endl;
                ret = m_meta->getReadEMCInfo(ser,&runfrm,&runto, m_calPar[2], res,runNo,m_bossver[2]);
        }

        //DedxCalConst
        if((cType=="DedxCal")&&(m_bossver[1]== "default" ))
        { 
                std::string cType="Dedx";
                if(m_bossRelease=="default") 
                {
                        log << MSG::FATAL << " Boss Release for DedxCal not set!" << endreq;
                        exit(1);                                                                                             
                }
                else              
                {
                        st1=getSftParVer(m_bossver[1],m_calPar[1],runfrm1,runto1,runNo,m_bossRelease,cType);
                        //cout<<cType<<" runfrm1,runto1 is:"<<runfrm1<<"::"<<runto1<<endl;
                        if (st1 .isFailure() ) 
                        {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;                              
                        }
                        ret = m_meta->getReadDedxInfo(ser,&runfrm,&runto, m_calPar[1], res,runNo,m_bossver[1]);                 
                }         
        }
        else if((cType=="DedxCal")&&(m_bossver[1]!= "default" ))   
        {
    m_flag[1]="set";
    flag=m_flag[1];
                //cout<<"flag @create Dedx is:"<<m_flag[1]<<endl;
                ret = m_meta->getReadDedxInfo(ser,&runfrm,&runto, m_calPar[1], res,runNo,m_bossver[1]);
        }

        //MdcCalConst
        if((cType=="MdcCal")&&(m_bossver[0]== "default" ))
        {
                std::string cType="Mdc";
                //cout<<"cType is"<<cType<<"m_bossver[0] is:"<<m_bossver[0]<<endl;
                if(m_bossRelease=="default") 
                {
                        log << MSG::FATAL << " Boss Release for MdcCal not set!" << endreq;
                        exit(1);      
                }
                else 
                {
                        st1=getSftParVer(m_bossver[0],m_calPar[0],runfrm1,runto1,runNo,m_bossRelease,cType);
                        //cout<<cType<<" runfrm1,runto1 is:"<<runfrm1<<"::"<<runto1<<endl;
                        if (st1 .isFailure() ) 
                        {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;                                                                            
                        }
                        ret = m_meta->getReadMDCInfo(ser,&runfrm,&runto,m_calPar[0],res,runNo,m_bossver[0]);                    
                }        
        }
        else if((cType=="MdcCal")&&(m_bossver[0]!= "default"))      
        {
    m_flag[0]="set";
    flag=m_flag[0];
                //cout<<"flag @create Mdc is:"<<m_flag[0]<<endl;
                ret = m_meta->getReadMDCInfo(ser,&runfrm,&runto, m_calPar[0], res,runNo,m_bossver[0]);

        }

        //MucCalConst
        if((cType=="MucCal")&&(m_bossver[4]== "default" ))
        {
                std::string cType="Muc";
                if(m_bossRelease=="default") 
                {
                        log << MSG::FATAL << " Boss Release for MucCal not set!" << endreq;
                        exit(1);                                                                                     
                }
                else 
                {
                        st1=getSftParVer(m_bossver[4],m_calPar[4],runfrm1,runto1,runNo,m_bossRelease,cType);
                        if (st1 .isFailure() ) 
                        {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;                                                                                                                                                                                        
                        }
                        ret = m_meta->getReadMUCInfo(ser,&runfrm,&runto, m_calPar[4], res,runNo,m_bossver[4]);                                                                                                                   
                }                                                
        }
        else if((cType=="MucCal")&&(m_bossver[4]!= "default" ))
        {
    m_flag[4]="set";
    flag=m_flag[4];
                //cout<<"flag @create Muc is:"<<m_flag[4]<<endl;
                ret = m_meta->getReadMUCInfo(ser,&runfrm,&runto, m_calPar[4], res,runNo,m_bossver[4]);                                               
        }

        //EsTimeCal
        if((cType=="EsTimeCal")&&(m_bossver[5]== "default" ))
        {
                std::string cType="EsTime";
                if(m_bossRelease=="default") 
                {
                        log << MSG::FATAL << " Boss Release for EsTimeCal not set!" << endreq;
                        exit(1);                                                                                                                              
                }
                else 
                {
                        st1=getSftParVer(m_bossver[5],m_calPar[5],runfrm1,runto1,runNo,m_bossRelease,cType);
                        if (st1 .isFailure() ) 
                        {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;                                                                                                                                                                                                                                                        
                        }
                        ret = m_meta->getReadEsTimeInfo(ser,&runfrm,&runto,m_calPar[5], res,runNo,m_bossver[5]);
                }                                                                                  
        }
        else if((cType=="EsTimeCal")&&(m_bossver[5]!= "default" ))
        {
    m_flag[5]="set";
    flag=m_flag[5];
                //cout<<"flag @create EsTime is:"<<m_flag[5]<<endl;
                ret = m_meta->getReadEsTimeInfo(ser,&runfrm,&runto, m_calPar[5], res,runNo,m_bossver[5]);                                                                    
        }

        //MdcAlign
        if((cType=="MdcAlign")&&(m_bossver[7]== "default" ))
        {
                std::string cType="MdcAlign";
                if(m_bossRelease=="default") {
                        log << MSG::FATAL << " Boss Release for MdcAlignCal not set!" << endreq;
                        exit(1);
                }
                else {
                        st1=getSftParVer(m_bossver[7],m_calPar[7],runfrm1,runto1,runNo,m_bossRelease,cType);
                        if (st1 .isFailure() ) {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;
                        }
                        ret = m_meta->getReadMdcAlignInfo(ser,&runfrm,&runto,m_calPar[7], res,runNo,m_bossver[7]);
                }
        }
        else if((cType=="MdcAlign")&&(m_bossver[7]!= "default" ))
        {
    m_flag[7]="set";
    flag=m_flag[7];
                //cout<<"flag @create MdcAlign is:"<<m_flag[7]<<endl;
                ret = m_meta->getReadMdcAlignInfo(ser,&runfrm,&runto, m_calPar[7], res,runNo,m_bossver[7]);
        }

        //TofQElec
        if((cType=="TofQElec")&&(m_bossver[8]== "default" ))
        {
                std::string cType="TofQElec";
                if(m_bossRelease=="default") {
                        log << MSG::FATAL << " Boss Release for TofQElecCal not set!" << endreq;
                        exit(1);
                }
                else {
                        //cout<<"TofQElec @create"<<endl;
                        st1=getSftParVer(m_bossver[8],m_calPar[8],runfrm1,runto1,runNo,m_bossRelease,cType);
                        if (st1 .isFailure() ) {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;
                        }
                        ret = m_meta->getReadTofQElecInfo(ser,&runfrm,&runto,m_calPar[8],res,runNo,m_bossver[8]);
                }
        }
        else if((cType=="TofQElec")&&(m_bossver[8]!= "default" ))
        {
    m_flag[8]="set";
    flag=m_flag[8];
                //cout<<"flag @create TofQElec is:"<<flag<<endl;
                ret = m_meta->getReadTofQElecInfo(ser,&runfrm,&runto, m_calPar[8], res,runNo,m_bossver[8]);
        }

        //TofSim
        if((cType=="TofSim")&&(m_bossver[9]== "default" ))
        {
                std::string cType="TofSim";
                if(m_bossRelease=="default") {
                        log << MSG::FATAL << " Boss Release for TofSimCal not set!" << endreq;
                        exit(1);
                }
                else {
                        st1=getSftParVer(m_bossver[9],m_calPar[9],runfrm1,runto1,runNo,m_bossRelease,cType);
                        if (st1 .isFailure() ) {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;
                        }
                        ret = m_meta->getReadTofSimInfo(ser,&runfrm,&runto, m_calPar[9], res,runNo,m_bossver[9]);
                }
        }
        else if((cType=="TofSim")&&(m_bossver[9]!= "default" ))
        {
    m_flag[9]="set";
    flag=m_flag[9];
                //cout<<"flag @create TofSim is:"<<m_flag[9]<<endl;
                ret = m_meta->getReadTofSimInfo(ser,&runfrm,&runto, m_calPar[9], res,runNo,m_bossver[9]);
        }

        //DedxSim
        if((cType=="DedxSim")&&(m_bossver[10]== "default" ))
        {
                std::string cType="DedxSim";
                if(m_bossRelease=="default") {
                        log << MSG::FATAL << " Boss Release for DedxSimCal not set!" << endreq;
                        exit(1);
                }
                else {
                        st1=getSftParVer(m_bossver[10],m_calPar[10],runfrm1,runto1,runNo,m_bossRelease,cType);
                        if (st1 .isFailure() ) {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;
                        }
                        ret = m_meta->getReadDedxSimInfo(ser,&runfrm,&runto,m_calPar[10], res,runNo,m_bossver[10]);
                }
        }
        else if((cType=="DedxSim")&&(m_bossver[10]!= "default" ))
        {
    m_flag[10]="set";
    flag=m_flag[10];
                //cout<<"flag @create DedxSim is:"<<m_flag[10]<<endl;
                ret = m_meta->getReadDedxSimInfo(ser,&runfrm,&runto, m_calPar[10], res,runNo,m_bossver[10]);
        }

        //MdcDataConst
        if((cType=="MdcDataConst")&&(m_bossver[11]== "default" ))
        {
                std::string cType="MdcData";
                if(m_bossRelease=="default") {
                        log << MSG::FATAL << " Boss Release for MdcDataConst not set!" << endreq;
                        exit(1);
                }
                else {
                        st1=getSftParVer(m_bossver[11],m_calPar[11],runfrm1,runto1,runNo,m_bossRelease,cType);
                        if (st1 .isFailure() ) {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;
                        }
                        ret = m_meta->getReadMdcDataConstInfo(ser,&runfrm,&runto,m_calPar[11], res,runNo,m_bossver[11]);
                }
        }
        else if((cType=="MdcDataConst")&&(m_bossver[11]!= "default" ))
        {
    m_flag[11]="set";
    flag=m_flag[11];
                //cout<<"flag @create MdcData is:"<<m_flag[11]<<endl;
                ret = m_meta->getReadMdcDataConstInfo(ser,&runfrm,&runto, m_calPar[11], res,runNo,m_bossver[11]);
        }

        //EstTofCalConst
        if((cType=="EstTofCal")&&(m_bossver[6]== "default" ))
        {
                std::string cType="EsTof";
                if(m_bossRelease=="default") {
                        log << MSG::FATAL << " Boss Release for EstTofCal not set!" << endreq;
                        exit(1);
                }
                else {
                        st1=getSftParVer(m_bossver[6],m_calPar[6],runfrm1,runto1,runNo,m_bossRelease,cType);
                        if (st1 .isFailure() ) {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;
                        }
                        ret = m_meta->getReadEstTofInfo(ser,&runfrm,&runto,m_calPar[6],res,runNo,m_bossver[6]);
                }
        }
        else if((cType=="EstTofCal")&&(m_bossver[6]!= "default" ))
        {
    m_flag[6]="set";
    flag=m_flag[6];
                //cout<<"flag @create EstTof is:"<<m_flag[6]<<endl;
                ret = m_meta->getReadEstTofInfo(ser,&runfrm,&runto, m_calPar[6], res,runNo,m_bossver[6]);
        }

        if(ret!=calibUtil::Metadata::RETOk){
                log <<  MSG::ERROR   << "no record in the database" << endreq;
                exit(1);
        }
        int sz=res.size();
        DatabaseRecord* records1 = res[0];
//      DatabaseRecord* records2 = res1[0];
 // runfrm1=records1->GetInt("RunFrom");
 // runto1=records1->GetInt("RunTo");
 // cout<<cType<<" runfrm1,runto1 is:"<<runfrm3<<":::"<<runto3<<endl;
        if(m_dbStatus=="OK"){
                if(std::string((*records1)["Status"])!="OK") {
                        log<<MSG::FATAL<<"Status of type "<<cType<<" is "<< (*records1)["Status"]<<"  your setting is OK"<<endreq;
                        exit(1);
                }
        }

        log << MSG::DEBUG << "dataIdent is:"<<dataIdent<< endreq;
        unsigned char storageType;
        physFmt="TREE";
        StatusCode sc = decodeDescription(physFmt, storageType);


        // Depending on value of eDataFmt, figure out which private
        // conversion service to invoke.  Pass dataIdent and fmtVersion
        // as part of the opaque address.  
        // Create temporary address for the relevant type and classID 
        log << MSG::DEBUG << "Creating an address of type "
                << (int)storageType << " for class " << classID << endreq;

        IOpaqueAddress* tmpAddress;
        const std::string par[3] = {dataIdent, fullpath, fmtVersion};
        //const unsigned long ipar[2] = {int(runfrm),int(runto)};
        //log << MSG::DEBUG << "ipar is:"<<ipar[0]<<":"<<ipar[1]<<"ipar[1]"<<endreq;
        const unsigned long ipar[2] = {0,0};//yzhang fix unsigned bug for runfrom runto

        //  sc = addressCreator()->createAddress(storageType, classID,
        //                                       par, ipar, tmpAddress);

        tmpAddress = new TreeAddress(storageType, classID,*records1,ipar);
  //sscanf((*records2)["RunFrom"], "%d", &runfrm1);
  //sscanf((*records2)["RunTo"], "%d", &runto1);
        
        cout<<cType<<" runfrm,runto @CalVtxLumVer is:"<<runfrm1<<":::"<<runto1<<endl;
        sscanf((*records1)["RunFrom"], "%d", &runfrm);
        sscanf((*records1)["RunTo"], "%d", &runto);
  log << MSG::DEBUG << __LINE__<<" records @ runfrm is:"<<(*records1)["RunFrom"]<<" runto is:"<<(*records1)["RunTo"]<<" ser_no is:"<<ser<<endreq;
        //log << MSG::DEBUG <<__LINE__<< " runfrm is:"<<runfrm<<" runto is:"<<runto<<" ser_no is:"<<ser<<endreq;
 if(flag=="default")
 {
        if(runfrm1>runfrm)
        {
                runfrm=runfrm1;
        }
        if(runto1<runto)
        {
                runto=runto1;
        }
 }
 if(flag=="set")
 {
         flag="default";
 }
        log << MSG::DEBUG <<__LINE__<< " runfrm of max is:"<<runfrm<<" runto min is:"<<runto<<endreq;
        TreeAddress* treeAddress =  dynamic_cast <TreeAddress*> (tmpAddress);
        treeAddress->setRunFrom(runfrm);
        treeAddress->setRunTo(runto);
//      log << MSG::DEBUG << __LINE__<<" records @ runfrm is:"<<(*records1)["RunFrom"]<<" runto is:"<<(*records1)["RunTo"]<<" ser_no is:"<<ser<<endreq;
//      log << MSG::DEBUG <<__LINE__<< " runfrm is:"<<runfrm<<" runto is:"<<runto<<" ser_no is:"<<ser<<endreq;
        /*
                 if ( !sc.isSuccess() ) {
                 log << msgLevel  << "Persistency service could not create a new address" << endreq;
                 if (m_crash) {
                 log << msgLevel << std::endl << "Exiting... " << std::endl << endreq;
                 exit(1);
                 }
                 return sc;
                 }
                 */
        tmpAddress->addRef();

        // Set the transient store registry for the object associated to this address
        tmpAddress->setRegistry(entry);

        // Now create the object
        sc = m_detPersSvc->createObj(tmpAddress, refpObject);
        tmpAddress->release();
        if ( !sc.isSuccess() ) {
                log << msgLevel
                        << "Persistency service could not create a new object" << endreq;
                if (m_crash) {
                        log << msgLevel << std::endl << "Exiting... " << std::endl << endreq;
                        exit(1);
                }
                return sc;
        }
        //  std::cout<<" CalibMySQLCnvSvc  res.size()=="<<res.size()<<std::endl;
        res.clear();
        log << MSG::DEBUG << "New object successfully created" << endreq;
        return StatusCode::SUCCESS;
        f1->Close();
        delete f1;
}



StatusCode CalibMySQLCnvSvc::updateCalib( DataObject*        pObject,
                const std::string& fullpath,
                const CLID&        classID,
                IRegistry*         entry )
{
        using CalibData::CalibBase;

        MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );
        StatusCode status;

        std::string testfile = std::string(getenv("CALIBMYSQLCNVROOT"))+"/share/test.root";
        TFile *f1=new TFile(testfile.c_str(),"read");


        // Look up calib object in the Metadata database
        //std::string flavor = CalibData::CalibModelSvc::getFlavor(fullpath);
        std::string cType = CalibData::CalibModelSvc::getCalibType(fullpath);

        // ..and extra special munging for test
        if (std::string("Test") == cType.substr(0, 4)) {
                cType = std::string("Test_Gen");
        }

        if (0 == pObject) {
                log << MSG::ERROR << "There is no DataObject to update" << endreq;
                return StatusCode::FAILURE;
        }
        // Is object an instance of the specified class?
        if(pObject->clID()!=6411&& classID!=6411){
                if ( classID != pObject->clID() ) {
                        log << MSG::ERROR << "Update requested for clID " << classID
                                << " while DataObject is of clID " 
                                << pObject->clID() << endreq;
                        exit(1);
                        return StatusCode::FAILURE;
                }
        }

        // check if already valid.  If so, we're done.
        //  Need access to IValidity interface
        CalibBase1* pBase = dynamic_cast<CalibBase1*>(pObject);
        if (pBase == 0) {
                log << MSG::WARNING
                        << "Object to be updated is not a calib object! " << endreq;
                return StatusCode::FAILURE;
        }

        // Following comes from createCalib.  Perhaps create and update
        // should be calling common utility since much of what they do is identical.
        unsigned int ser;
        int runfrm,runfrm1;
        int runto,runto1;
        calibUtil::Metadata::eRet ret;

        //  calibUtil::Metadata::eDataFmt physFmt = calibUtil::Metadata::FMTUnknown;
        std::string physFmt;
        std::string fmtVersion;
        std::string dataIdent;
        std::string flag="default";
        // Get the information needed to find and interpret the bulk data:
        //   * physical storage type
        //   * version of the physical format
        //   * pathname or similar identifying information so the data can be found
        //   maqm comment remove fmtversion :
        //    ret = m_meta->getReadInfo(ser, physFmt, fmtVersion, dataIdent);

        SmartDataPtr<Event::EventHeader> evt(m_eventSvc,"/Event/EventHeader");
        int runNo=0;
        if( !evt ){
                log << MSG::WARNING << "Unable to read the Event for TDS" << endreq;
                //     return StatusCode::FAILURE;
        }

        //  eRet ret;

        DatabaseRecordVector res;
        StatusCode st1;
        if( evt ){
                if(cType!="TofCal"&&cType!="EstTofCal"&&cType!="TofSim"&&cType!="DedxSim") runNo = fabs(evt -> runNumber());
                if(cType=="TofCal"||cType=="EstTofCal"||cType=="TofSim"||cType=="DedxSim") runNo = evt -> runNumber();
        }

        //TofCalConst
        if((cType=="TofCal"))
        {
                std::string cType="Tof";
                if(m_flag[3]=="default")
                {
                        st1=getSftParVer(m_bossver[3],m_calPar[3],runfrm1,runto1,runNo,m_bossRelease,cType);
                        //cout<<cType<<" runfrm1,runto1 @update is:"<<runfrm1<<":::"<<runto1<<endl;
                        if (st1 .isFailure() ) 
                        {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;                                                         
                        }
                }
        
                flag=m_flag[3];

    //cout<<"flag @update Tof is:"<<flag<<endl;
                        //cout<<"SftVer and CalParVer are:"<<sft_ver<<";"<<cal_ver<<endl;
                ret = m_meta->getReadTOFInfo(ser,&runfrm,&runto,m_calPar[3],res,runNo,m_bossver[3]);
        }

        //EmcCalConst
        if((cType=="EmcCal"))   
        { 
                std::string cType="Emc";
                if(m_flag[2]=="default")
                {
                        st1=getSftParVer(m_bossver[2],m_calPar[2],runfrm1,runto1,runNo,m_bossRelease,cType);
                        //cout<<cType<<" runfrm1,runto1 @update is:"<<runfrm1<<":::"<<runto1<<endl;
                        if (st1 .isFailure() ) 
                        {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;                                
                        }
                }
                flag=m_flag[2];
                //cout<<"flag @update Emc is:"<<m_flag[2]<<endl;
                ret = m_meta->getReadEMCInfo(ser,&runfrm,&runto, m_calPar[2], res,runNo,m_bossver[2]);                    
        }



        //DedxCalConst
        if((cType=="DedxCal"))
        { 
                std::string cType="Dedx";
                if(m_flag[1]=="default")
                {
                        st1=getSftParVer(m_bossver[1],m_calPar[1],runfrm1,runto1,runNo,m_bossRelease,cType);
                        //cout<<cType<<" runfrm1,runto1 @update is:"<<runfrm1<<":::"<<runto1<<endl;
                        if (st1 .isFailure() ) 
                        {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;                              
                        }
                }
                flag=m_flag[1];
                //cout<<"flag @update Dedx  is:"<<m_flag[1]<<endl;
                ret = m_meta->getReadDedxInfo(ser,&runfrm,&runto, m_calPar[1], res,runNo,m_bossver[1]);                 
        }         

        //MdcCalConst
        if((cType=="MdcCal"))
        {
                std::string cType="Mdc";
                if(m_flag[0]=="default")
                {
                        //cout<<"cType is"<<cType<<"m_bossver[0] is:"<<m_bossver[0]<<endl;
                        st1=getSftParVer(m_bossver[0],m_calPar[0],runfrm1,runto1,runNo,m_bossRelease,cType);
                        //cout<<cType<<" runfrm1,runto1 @update is:"<<runfrm1<<":::"<<runto1<<endl;
                        if (st1 .isFailure() ) 
                        {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;                                                                            
                        }
                }
                flag=m_flag[0];
                //cout<<"flag @update Mdc is:"<<m_flag[0]<<endl;
                ret = m_meta->getReadMDCInfo(ser,&runfrm,&runto,m_calPar[0],res,runNo,m_bossver[0]);                    
        }        

        //MucCalConst
        if((cType=="MucCal"))
        {
                std::string cType="Muc";
                if(m_flag[4]=="default")
                {
                        st1=getSftParVer(m_bossver[4],m_calPar[4],runfrm1,runto1,runNo,m_bossRelease,cType);
                        //cout<<cType<<" runfrm1,runto1 @update is:"<<runfrm1<<":::"<<runto1<<endl;
                        if (st1 .isFailure() ) 
                        {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;                                                                                                                                                                                        
                        }
                }
                flag=m_flag[4];
                //cout<<"flag @update Muc is:"<<m_flag[4]<<endl;
                ret = m_meta->getReadMUCInfo(ser,&runfrm,&runto, m_calPar[4], res,runNo,m_bossver[4]);                                                                                                                   
        }                                                

        //EsTimeCal
        if((cType=="EsTimeCal"))
        {
                std::string cType="EsTime";
                if(m_flag[5]=="default")
                {
                        st1=getSftParVer(m_bossver[5],m_calPar[5],runfrm1,runto1,runNo,m_bossRelease,cType);
                        //cout<<cType<<" runfrm1,runto1 @update is:"<<runfrm1<<":::"<<runto1<<endl;
                        if (st1 .isFailure() ) 
                        {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;                                                                                                                                                                                                                                                        
                        }
                }
                flag=m_flag[5];
                //cout<<"flag @update EsTime is:"<<m_flag[5]<<endl;
                ret = m_meta->getReadEsTimeInfo(ser,&runfrm,&runto,m_calPar[5], res,runNo,m_bossver[5]);
        }                                                                                  

        //MdcAlign
        if((cType=="MdcAlign"))
        {
                std::string cType="MdcAlign";
                if(m_flag[7]=="default")
                {
                        st1=getSftParVer(m_bossver[7],m_calPar[7],runfrm1,runto1,runNo,m_bossRelease,cType);
                        //cout<<cType<<" runfrm1,runto1 @update is:"<<runfrm1<<":::"<<runto1<<endl;
                        if (st1 .isFailure() ) {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;
                        }
                }
                flag=m_flag[7];
                //cout<<"flag @update MdcAlign is:"<<m_flag[7]<<endl;
                ret = m_meta->getReadMdcAlignInfo(ser,&runfrm,&runto,m_calPar[7], res,runNo,m_bossver[7]);
        }

        //TofQElec
        if((cType=="TofQElec"))
        {
                std::string cType="TofQElec";
                if(m_flag[8]=="default")
                {
                        //cout<<"TofQElec @update"<<endl;
                        st1=getSftParVer(m_bossver[8],m_calPar[8],runfrm1,runto1,runNo,m_bossRelease,cType);
                        //cout<<cType<<" runfrm1,runto1 @update is:"<<runfrm1<<":::"<<runto1<<endl;
                }
                flag=m_flag[8];
                //cout<<"flag @update TofQElec is:"<<m_flag[8]<<endl;
                ret = m_meta->getReadTofQElecInfo(ser,&runfrm,&runto,m_calPar[8],res,runNo,m_bossver[8]);
        }

        //TofSim
        if((cType=="TofSim"))
        {
                std::string cType="TofSim";
                if(m_flag[9]=="default")
                {
                        st1=getSftParVer(m_bossver[9],m_calPar[9],runfrm1,runto1,runNo,m_bossRelease,cType);
                        //cout<<cType<<" runfrm1,runto1 @update is:"<<runfrm1<<":::"<<runto1<<endl;
                        if (st1 .isFailure() ) {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;
                        }
                }
                flag=m_flag[9];
                //cout<<"flag @update TofSim is:"<<m_flag[9]<<endl;
                ret = m_meta->getReadTofSimInfo(ser,&runfrm,&runto, m_calPar[9], res,runNo,m_bossver[9]);
        }

        //DedxSim
        if((cType=="DedxSim"))
        {
                std::string cType="DedxSim";
                if(m_flag[10]=="default")
                {
                        st1=getSftParVer(m_bossver[10],m_calPar[10],runfrm1,runto1,runNo,m_bossRelease,cType);
                        //cout<<cType<<" runfrm1,runto1 @update is:"<<runfrm1<<":::"<<runto1<<endl;
                        if (st1 .isFailure() ) {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;
                        }
                }
                flag=m_flag[10];
                //cout<<"flag @update DedxSim is:"<<m_flag[10]<<endl;
                ret = m_meta->getReadDedxSimInfo(ser,&runfrm,&runto,m_calPar[10], res,runNo,m_bossver[10]);
        }

        //MdcDataConst
        if((cType=="MdcDataConst"))
        {
                std::string cType="MdcData";
                if(m_flag[11]=="default")
                {
                        st1=getSftParVer(m_bossver[11],m_calPar[11],runfrm1,runto1,runNo,m_bossRelease,cType);
                        //cout<<cType<<" runfrm1,runto1 @update is:"<<runfrm1<<":::"<<runto1<<endl;
                        if (st1 .isFailure() ) {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;
                        }
                }
                flag=m_flag[11];
                //cout<<"flag @update MdcData is:"<<m_flag[11]<<endl;
                ret = m_meta->getReadMdcDataConstInfo(ser,&runfrm,&runto,m_calPar[11], res,runNo,m_bossver[11]);
        }

        //EstTofCalConst
        if((cType=="EstTofCal"))
        {
                std::string cType="EsTof";
                if(m_flag[6]=="default")
                {
                        st1=getSftParVer(m_bossver[6],m_calPar[6],runfrm1,runto1,runNo,m_bossRelease,cType);
                        //cout<<cType<<" runfrm1,runto1 @update is:"<<runfrm1<<":::"<<runto1<<endl;
                        if (st1 .isFailure() ) {
                                log << MSG::ERROR << " Unable to find DatabaseSvc " << endreq;
                                return st1;
                        }
                }
                flag=m_flag[6];
                //cout<<"flag @update EstTof is:"<<m_flag[6]<<endl;
                ret = m_meta->getReadEstTofInfo(ser,&runfrm,&runto,m_calPar[6],res,runNo,m_bossver[6]);
        }

        if(ret!=calibUtil::Metadata::RETOk){
                log <<  MSG::ERROR   << "Error searching in the database" << endreq;
                exit(1);
        }

        physFmt="TREE";
        unsigned char storageType;
        status = decodeDescription(physFmt, storageType);

        // Depending on value of eDataFmt, figure out which private
        // conversion service to invoke.  Pass dataIdent and fmtVersion
        // as part of the opaque address.  
        // Create temporary address for the relevant type and classID 
        log << MSG::DEBUG << "Creating an address of type " 
                << (int)storageType << " for class " << classID << endreq;

        //   int sz=res.size();
        DatabaseRecord* records1 = res[0];

        if(m_dbStatus=="OK"){
                if(std::string((*records1)["Status"])!="OK") {
                        log<<MSG::FATAL<<"the status of type  "<<cType<<" is "<< (*records1)["Status"]<<"  your setting is OK"<<endreq;
                        exit(1);
                }
        }


        IOpaqueAddress* tmpAddress;
        //const unsigned long ipar[2] = {runfrm,runto};
        const unsigned long ipar[2] = {0,0};//yzhang fix unsigned bug for runfrom runto

        tmpAddress = new TreeAddress(storageType, classID,*records1,ipar);
  log << MSG::DEBUG <<__LINE__<<cType<<" runfrm,runto @CalVtxLumVer/update  is:"<<runfrm1<<":::"<<runto1<<endreq;
        sscanf((*records1)["RunFrom"], "%d", &runfrm);
        sscanf((*records1)["RunTo"], "%d", &runto);
        log << MSG::DEBUG << __LINE__<<" records @update runfrm is:"<<(*records1)["RunFrom"]<<" runto is:"<<(*records1)["RunTo"]<<" ser_no is:"<<ser<<endreq;
        if(flag=="default")
        {
                if(runfrm1>runfrm)
                  {
                    runfrm=runfrm1;
                        }
    if(runto1<runto)
      {
       runto=runto1;
      } 
        }
        if(flag=="set")
        {
                flag=="default";
        }

 log << MSG::DEBUG <<__LINE__<< " runfrm of max is:"<<runfrm<<" runto min is:"<<runto<<endreq;
        TreeAddress* treeAddress =  dynamic_cast <TreeAddress*> (tmpAddress);
        treeAddress->setRunFrom(runfrm);
        treeAddress->setRunTo(runto);
        //log << MSG::DEBUG << __LINE__<<" records runfrm is:"<<(*records1)["RunFrom"]<<" runto is:"<<(*records1)["RunTo"]<<" ser_no is:"<<ser<<endreq;
        //log << MSG::DEBUG <<__LINE__<< " runfrm is:"<<runfrm<<" runto is:"<<runto<<" ser_no is:"<<ser<<endreq;

        log << MSG::DEBUG << "Temporary address successfully created" << endreq;
        tmpAddress->addRef();

        // Set the transient store registry for the object associated to this address
        tmpAddress->setRegistry(entry);

        // Now update the object
        DataObject* pNewObject;
        status = m_detPersSvc->createObj(tmpAddress, pNewObject);
        tmpAddress->release();
        if ( !status.isSuccess() ) {
                log << MSG::ERROR 
                        << "Persistency service could not create object" << endreq;
                return status;
        }

        // Since DataObject::operator= operator is not virtual, dynamic cast first!
        // Overloaded virtual method Condition::update() must be properly defined!
        // The memory pointed to by the old pointer must contain the new object    
        // Note this dynamic cast only gets us part-way.  The object is
        // actually of some type derived from CalibBase.
        CalibBase1* pNewBase = dynamic_cast<CalibBase1*>(pNewObject);
        if  (0 == pNewBase) {
                log << MSG::ERROR
                        << "Cannot update objects other than Calib objects: " 
                        << "update() must be defined!"
                        << endreq;
                return StatusCode::FAILURE;
        }

        // Deep copy the new calib into the old DataObject.  To copy the *whole*
        // object, not just the CalibBase part, classes derived from CalibBase
        // must override update method.  
        // NOTE:  classes directly derived from CalibBase must call
        //        CalibBase::update in their own update method.
        pBase->update(*pNewBase, &log);  
        res.clear();
        f1->Close();
        delete f1;
        delete pNewBase;
        return StatusCode::SUCCESS;
}

StatusCode  CalibMySQLCnvSvc::decodeDescription(const std::string& description,
                unsigned char& type )
{
        MsgStream log(msgSvc(), "CalibMySQLCnvSvc");

        //   description ="ROOT";
        if (description == std::string("XML")) {
                type = XML_StorageType;
        }
        else if (description == std::string("ROOT")) {
                type = CALIBROOT_StorageType;
        }
        else if (description == std::string("TREE")) {
                type = CALIBTREE_StorageType;
        }
        else {       // unsupported
                log << MSG::ERROR << "unsupported storage type " << description << endreq;
                return StatusCode::FAILURE;
        }
        return StatusCode::SUCCESS;
}


calibUtil::Metadata* CalibMySQLCnvSvc::getMeta( ) {
        return m_meta;
}

---