GSICycleDescriptor.cpp

Go to the documentation of this file.

//Copyright GSI 2012
#include <fesa-core-gsi/Synchronization/GSICycleDescriptor.h>
#include <fesa-core/Core/AbstractEquipment.h>
#include <fesa-core/Utilities/Lock.h>
#include <fesa-core-gsi/Exception/GSIException.h>


#include <sstream>
#include <iostream>

namespace fesaGSI
{
        GSICycleDescriptor::GSICycleDescriptor(const std::string& machineName,const std::string& groupName) :
                fesa::CycleDescriptor(machineName,groupName)
    {
        tgmMachineName_ = machineName;
        tgmGroupName_ = groupName;

        log_ = fesa::FesaLogger::getLogger(fesa::evtLogName, "GSICycleDescriptor", fesa::AbstractEquipment::getInstance()->getEquipmentName());

        //since TgmGetMachineId does a hard "exit" on failure, we need to cout+log some text here
        //The file-descriptor-check we do in the TimingEventSource does not work here
        std::string bevoreTgmGetMachineId1;
        std::string bevoreTgmGetMachineId2;
        bevoreTgmGetMachineId1 += "Accessing Timlib to get maschineID (This CERN-Timing method does a hard exit on failure)";
        bevoreTgmGetMachineId2 += "Caution: If your application crashes in this line, you are possibly running a Timing-class on a FEC which is not connected to the Timing-Network.";
        std::string afterTgmGetMachineId;
        afterTgmGetMachineId += "Timlib-access was successful";

        log_->send(bevoreTgmGetMachineId1.c_str(),log_->traceType);
        std::cout << bevoreTgmGetMachineId1 << std::endl;
        log_->send(bevoreTgmGetMachineId2.c_str(),log_->traceType);
        std::cout << bevoreTgmGetMachineId2 << std::endl;
        tgmMachineID_ = TgmGetMachineId((char*) tgmMachineName_.c_str());
        log_->send(afterTgmGetMachineId.c_str(),log_->traceType);
        std::cout << afterTgmGetMachineId << std::endl;

        //seems to be the constant for 'machine not valid'
        if(tgmMachineID_ == 4294967295)
        {
            throw GSIException(__FILE__, __LINE__,FESAGSIErrorWrongMachineName.c_str(),tgmMachineName_.c_str());
        }

        tgmGroup_ = TgmGetGroupNumber((TgmMachine) tgmMachineID_, (char*) tgmGroupName_.c_str());

        if (TgmGetGroupDescriptor((TgmMachine) tgmMachineID_, tgmGroup_, &group_) != TgmSUCCESS)
        {
            throw GSIException(__FILE__, __LINE__,FESAGSIErrorGroupDescriptorFailedForMachine.c_str(),
                            tgmMachineName_.c_str(), tgmGroupName_.c_str());
        }

        // line names go from minimum value to maximum
        // In case of numerical value or bit-pattern the lineNameCol and timingSelectorCol are empty
        if (group_.Type == TgmEXCLUSIVE)
        {
            refreshData();
        }
        else
        {
            lineNamesCol_.push_back("");
            addSelector("");
        }
    }

        GSICycleDescriptor::~GSICycleDescriptor()
    {

    }

    void GSICycleDescriptor::refreshData()
    {
        if (group_.Type == TgmEXCLUSIVE)
        {
            TgmLineNameTable lnt;
            if (TgmGetLineNameTable((TgmMachine) tgmMachineID_, (char*) tgmGroupName_.c_str(), &lnt) == TgmSUCCESS)
            {
                for (unsigned int i = 0; i < lnt.Size; ++i)
                {
                    std::string s(lnt.Table[i].Name);

                    if (lineNamesCol_.size() > i) // if element exists
                    {
                        if (lineNamesCol_[i] != s) // rename existing element
                        {
                                std::string oldName = tgmMachineName_ + "." + tgmGroupName_ + "." + lineNamesCol_[i];
                                std::string newName = tgmMachineName_ + "." + tgmGroupName_ + "." + s;
                            renameSelector(oldName,newName);
                            lineNamesCol_[i] = s;
                        }
                    }
                    else
                    {
                        lineNamesCol_.push_back(s);
                        addSelector(tgmMachineName_ + "." + tgmGroupName_ + "." + s);
                    }
                }
            }
        }
    }

    bool GSICycleDescriptor::isValidCycleSelector(const std::string& timingSelectorName)
    {
        if (group_.Type == TgmEXCLUSIVE)
        {
            if (TgmCheckTable((TgmMachine) tgmMachineID_, TgmLINE_NAMES))
            {
                refreshData();
            }

            //call the baseclass method after refresh
            return CycleDescriptor::isValidCycleSelector(timingSelectorName);
        }
        else
        {
            size_t sep = timingSelectorName.rfind('.');
            if (sep == std::string::npos)
            {
                throw GSIException(__FILE__, __LINE__,FESAGSIErrorTimingSelectorSeparatorNotFound.c_str(),'.', timingSelectorName.c_str());
            }
            std::string lineName = timingSelectorName.substr(sep + 1, timingSelectorName.size() - sep - 1);

            int val = atoi(lineName.c_str());
            if ((val >= group_.Minimum) && (val <= group_.Maximum))
            {
                return true;
            }
        }
        return false;
    }

    int GSICycleDescriptor::getCycleSelectorId(const std::string& timingSelectorName)
    {
        if (group_.Type == TgmEXCLUSIVE)
        {
            if (TgmCheckTable((TgmMachine) tgmMachineID_, TgmLINE_NAMES))
            {
                refreshData();
            }

            //call the baseclass method after refresh
            return CycleDescriptor::getCycleSelectorId(timingSelectorName);
        }
        else
        {
            return 0;
        }
    }

    const std::string GSICycleDescriptor::getCycleSelectorName(int timingSelectorID)
    {
        if (group_.Type == TgmEXCLUSIVE)
        {
            if (TgmCheckTable((TgmMachine) tgmMachineID_, TgmLINE_NAMES))
            {
                refreshData();
            }

            //call the baseclass method after refresh
            return CycleDescriptor::getCycleSelectorName(timingSelectorID);
        }
        else
        {
            return CycleDescriptor::getCycleSelectorName(0);
        }
    }

    int GSICycleDescriptor::getTgmGroupId()
    {
        return tgmGroup_;
    }
}