---

ModuleDefect.h

Go to the documentation of this file.

#ifndef MODULEDEFECT_H
#define MODULEDEFECT_H

#include "Sct/Streamable.h"
#include <cstdio>
#include <string>
#include <memory>
#include <map>
#include "Sct/LogicErrors.h"
#include "Sct/SctParameters.h"
#include "ModuleElement.h"

using namespace std;
using Sct::Streamable;

namespace SctData {

    class ModuleDefect : public Streamable {
      public:
    //Defect Prototypes: 
      
    static const ModuleDefect DEAD;         ///< Output always v small
    static const ModuleDefect STUCKON;  
    static const ModuleDefect OVER;     
    static const ModuleDefect UNDER;    
        static const ModuleDefect NOINIT;   
    static const ModuleDefect FIT_UNDER;
    static const ModuleDefect FIT_OVER;
        static const ModuleDefect SIG_UNDER;
    static const ModuleDefect SIG_OVER;

    static const ModuleDefect SD_LO;    
    static const ModuleDefect SD_HI;    


    static const ModuleDefect LO_GAIN;   
    static const ModuleDefect HI_GAIN;    
    static const ModuleDefect LO_OFFSET; 
    static const ModuleDefect HI_OFFSET;  
    static const ModuleDefect UNBONDED;     
        static const ModuleDefect PARTBONDED;   
    static const ModuleDefect NOISY;   


    static const ModuleDefect TR_RANGE;      
    static const ModuleDefect TR_STEP;       
    static const ModuleDefect TR_OFFSET;     
        static const ModuleDefect TR_NOTRIM;    


    static const ModuleDefect NO_HI;    
    static const ModuleDefect MEAN_ERROR;
    static const ModuleDefect SIG_ERROR;
    static const ModuleDefect STUCK_CELL; 
    static const ModuleDefect DEAD_CELL; 
    static const ModuleDefect TOKEN;     
    static const ModuleDefect RTOKEN;    
    static const ModuleDefect TW_HI;     
    static const ModuleDefect TW_LO;     


    //Methods
    ModuleDefect(const ModuleDefect & prototype, const ModuleElement& element) throw () ;
    virtual ~ModuleDefect() throw() {
    }
        //Operations        
        bool isSevere() const throw() ;
    const ModuleElement& getModuleElement() const throw(LogicError); 
    bool isPrototype() const throw() ;

    bool isChipDefect() const throw() ;

    bool isLinkDefect() const throw() ;

    bool isUnfittable() const throw() ;

    bool isUnuseable() const throw() ;

    bool isDodgy() const throw() ;

        const string& getName() const throw() ;

    const string & getDescription() const throw() ;
        
        double getParameter() const throw() ;

    bool isOfTheSameTypeAs(const ModuleDefect & defect) const throw() ;
    bool operator ==(const ModuleDefect & defect) const throw(LogicError) ;
    
    //Streamable override
    virtual string getClassName() const throw() ;

      private:
    ModuleDefect(int id, bool severe, const string& name, const string & d, double parameter) throw() ;
        ModuleDefect(int id, bool severe, const string& name, const char* d, double parameter) throw() ;

    //ModuleDefect(const ModuleDefect & copy);

    //Data          
    int id;         
    bool severe;        
        string name;            
    string description; 
        double parameter;       
    auto_ptr<ModuleElement> element;    

    //IOHelper stuff
    friend class ModuleDefectIOHelper;
    static map <int, ModuleDefect*> defectMap;
    };

//Inlines
    inline ModuleDefect::ModuleDefect(int id, bool severe, const string& name, const string & d, double parameter) throw()
                                      :id(id), severe(severe), name(name), description(d), parameter(parameter), element(0) {
    //Add to map
    defectMap[id] = this;
    }
    
    inline ModuleDefect::ModuleDefect(int id, bool severe, const string& name, const char* d, double parameter) throw() 
                                      :id(id), severe(severe), name(name), description(""), parameter(parameter), element(0) {
    //Add to map
    defectMap[id] = this;

        char temp[100];
        sprintf(temp, d, parameter);
        description = temp;                                                 
    }

    inline ModuleDefect::ModuleDefect(const ModuleDefect & prototype, const ModuleElement& el) throw()
    :id(prototype.id), severe(prototype.severe), name(prototype.name), description(prototype.description), parameter(prototype.parameter), element(new ModuleElement(el)) {
    }

    inline double ModuleDefect::getParameter() const throw() {
        return parameter;
    }
    
    inline bool ModuleDefect::isPrototype() const throw() {
    return (element.get()==0);
    } 

    inline bool ModuleDefect::operator ==(const ModuleDefect & defect) const throw(LogicError) {
    return (id == defect.id && getModuleElement() == defect.getModuleElement() );
    }
    inline bool ModuleDefect::isOfTheSameTypeAs(const ModuleDefect & defect) const throw() {
    return (id == defect.id);
    }
    inline const ModuleElement& ModuleDefect::getModuleElement() const throw(LogicError) {
    if (element.get()==0){
        throw IllegalStateError("ModuleDefect::getModuleElement not available for prototype", __FILE__, __LINE__);
    }
    return *element;
    }
    
    inline bool ModuleDefect::isChipDefect() const throw() {
    return getModuleElement().isChip();
    }
    
    inline bool ModuleDefect::isLinkDefect() const throw() {
    return getModuleElement().isLink(); 
    }    
    
    inline bool ModuleDefect::isSevere() const throw() {
    return severe;
    } 
    
    inline bool ModuleDefect::isUnfittable() const throw() {
    return (isOfTheSameTypeAs(OVER) || isOfTheSameTypeAs(UNDER) || 
        isOfTheSameTypeAs(STUCKON) );
    } 
    
    inline bool ModuleDefect::isUnuseable() const throw() {
    return (isOfTheSameTypeAs(DEAD) || isOfTheSameTypeAs(STUCKON) );
    } 
    
    inline bool ModuleDefect::isDodgy() const throw() {
    return !(isOfTheSameTypeAs(DEAD) || isOfTheSameTypeAs(STUCKON) );
    } 
    
    inline const string& ModuleDefect::getName() const throw() { 
        return name;
    }
    
    inline const string & ModuleDefect::getDescription() const throw() {
    return description;
    } 
    
    inline string ModuleDefect::getClassName() const throw() {
    return "SctData::ModuleDefect";
    }
}
#endif              //#ifndef MODULEDEFECT_H

---