ADCChannelMapping.cc

Go to the documentation of this file.

/* ADCChannelMapping.cc
 * $Id$
 */

#include "ADCChannelMapping.h"
#include <Exceptions.h>

namespace tpcconddata
{

    std::string ADCChannelMapping::getRevision()
    {
        return std::string("$Rev: 2568 $");
    }

    std::string ADCChannelMapping::getDefaultColName()
    {
        return std::string("TPCChannelMapping");
    }

    ADCChannelMapping::ADCChannelMapping(int channelID, int padIndex, int type , int moduleID,
        int readoutGroup)
        : _createObj(true)       // remember that we have to delete the object in the destructor
    {
        // create a fixed size generic object with 5 ints
        _myObj     = new IMPL::LCGenericObjectImpl(5,0,0);

        // set the 4 values
        _myObj->setIntVal( 0, channelID) ;
        _myObj->setIntVal( 1, padIndex) ;
        _myObj->setIntVal( 2, type) ;
        _myObj->setIntVal( 3, moduleID) ;
        _myObj->setIntVal( 4, readoutGroup) ;
    }

    ADCChannelMapping::ADCChannelMapping(EVENT::LCObject* obj)
        : _createObj(false)      // we did not create the object, so we must not delete it in the d'tor
    {
        // initialise the object pointer
        _myObj = dynamic_cast<IMPL::LCGenericObjectImpl*>(obj);

        if (_myObj == 0)         // the cast did not succeed
        {
            throw lcio::Exception("Cannot create ADCChannelMapping from sth."
                " that is not LCGenericObjectImpl" ) ;
        }

        // check the size of the generic object
        // there have to be 3 or 4 interes, no floats ot doubles
        if (  ( ( _myObj->getNInt()    != 3 ) &&  ( _myObj->getNInt()    != 5 ) )  ||
            ( _myObj->getNFloat()  != 0 )  ||
            ( _myObj->getNDouble() != 0 )
            )
        {
            throw lcio::Exception("ADCChannelMapping(LCObject* obj): Wrong number of elements in object" ) ;
        }

    }

    ADCChannelMapping::~ADCChannelMapping()
    {
        // delete the LCGenericObjectImpl, but only if it was created in the constructor
        if( _createObj)
            delete (_myObj);
    }

    int ADCChannelMapping::getChannelID() const
    {
        return _myObj->getIntVal( 0 ) ;
    }

    int ADCChannelMapping::getPadID() const
    {
        return _myObj->getIntVal( 1 ) ;
    }

    int ADCChannelMapping::getType() const
    {
        return _myObj->getIntVal( 2 ) ;
    }

    int ADCChannelMapping::getModuleID() const
    {
        // This implementation should be backward compatible to the version
        // without moduleID, so the generic object might only contain 3 integers.
        // Return moduleID = 0 in this case.

        if ( _myObj->getNInt() >=4)
        {
            return _myObj->getIntVal( 3 ) ;
        }
        else
        {
            return 0;
        }
    }

    int ADCChannelMapping::getReadoutGroup() const
    {
        // This implementation should be backward compatible to the version
        // without readoutGroup, so the generic object might only contain 3 integers.
        // Return moduleGroup = 0 in this case.

        if ( _myObj->getNInt() >=5)
        {
            return _myObj->getIntVal( 4 ) ;
        }
        else
        {
            return 0;
        }
    }

    void ADCChannelMapping::print ( std::ostream& os ) const
    {
        os<<"ADCChannelMapping: Pad  "<<getPadID()
            <<" <-> "
            <<"Channel "<<getChannelID()
            <<" Type: "<<getType()<<" ; "
            <<"ModuleID " <<getModuleID()
            <<std::endl;
    }

    std::ostream &operator<<(std::ostream &os, const ADCChannelMapping &acm)
    {
        acm.print(os);
        return os;
    }

    #ifdef USE_LCCD
    ADCChannelMapping::key_type ADCChannelMapping::softwareToHardwareKey() const
    {

        return key_type( getPadID(), getModuleID() );
    }

    ADCChannelMapping::key_type ADCChannelMapping::hardwareToSoftwareKey() const
    {

        return key_type( getChannelID(), getReadoutGroup() );
    }
    #endif

} //namespace