ChipConfiguration.java

/*
 * ChipConfiguration.java
 *
 * Created on 16 September 2003, 16:35
 */

package SctData;

import Sct.*;
import sctConf.*;

public class ChipConfiguration implements Streamable {
    
    public ChipConfiguration(ABCDChip data) {
        this.data = data;
        options = new ChipOptions(data.basic.config);
    }
    
    public ABCDChip getData() {
        return data;
    }
    
    public ChipOptions getOptions() {
        return options;
    }
    
    public boolean isActive() {
        return data.active != 0;
    }
    
    public void setActive(boolean active) {
        data.active = active ? (byte)1 : (byte)0;
    }
    
    public byte getAddress() {
        return data.address;
    }
    
    public byte getTrimTarget() {
        return data.target;
    }
    
    public void setTrimTarget(byte target) {
        data.target = target;
    }
    
    public byte getTrim(int channel) {
        return data.trim[channel];
    }
    
    public void setTrim(int channel, byte trim) throws IllegalArgumentException {
        if (trim > 15 || trim < 0) throw new IllegalArgumentException("Trim must be 0->15, channel: " + channel + " trim: " + trim);
        data.trim[channel] = trim;
    }
    
    public byte getThreshold() {
        return data.basic.vthr;
    }
    
    public void setThreshold(byte threshold) {        
        data.basic.vthr = threshold;
    }
    
    public byte getCalCharge() {
        return data.basic.vcal;
    }
    
    public void setCalCharge(byte calCharge) {        
        data.basic.vcal = calCharge;
    }
    
    public byte getStrobeDelay() {
        return data.basic.delay;
    }
    
    public void setStrobeDelay(byte strobeDelay) throws IllegalArgumentException {
        if (strobeDelay > 63 || strobeDelay < 0) throw new IllegalArgumentException("delay must be 0->63, delay: " + strobeDelay);
        data.basic.delay = strobeDelay;
    }
    
    
    public void resetMask() {
       for (int i=0; i<data.basic.mask.length; ++i) {
           data.basic.mask[i] = 0;
       }
    }
    
    public void setMask(int ichannel, boolean value) {
        if (value) mask(ichannel); 
        else unmask(ichannel);
    }
    
    public void mask(int ichannel) {
        data.basic.mask[ichannel/32] &= ~(1<<ichannel%32);
    }
    
    public void unmask(int ichannel) {
        data.basic.mask[ichannel/32] |= (1<<ichannel%32);
    }
    
    public boolean isMasked(int ichannel) {
        return (data.basic.mask[ichannel/32] & (1<<ichannel%32)) == 0;
    }
    
    public byte getRcFunctionIndex() {
        return data.caldata.rc_function;
    }
    
    public void setRcFunctionIndex(byte index)  throws IllegalArgumentException {
        if (index > 4 || index <= 0) throw new IllegalArgumentException("rcFunction must be 1->4, rcFunction: " + index);
        data.caldata.rc_function = index;        
    }
    
    public double getRcParam(int ipar) {
        return data.caldata.rc_params[ipar];
    }
    
    public void setRcParam(int ipar, double val) {
        data.caldata.rc_params[ipar] = (float)val;
    }
    

    public void setCalFactor(float factor) {
        data.caldata.c_factor = factor;
    }
    
    public float getCalFactor() {
        return data.caldata.c_factor;
    }    
    
    public String getClassName() {
        return "SctData.ChipConfiguration";
    }
    
    public static Streamable read(IStream s, ObjectManager o) throws java.io.IOException {
        ABCDChip data = new ABCDChip();
        data.basic = new ABCDBasic();
        data.caldata = new ABCDCaldata();        
        ChipConfiguration c = new ChipConfiguration(data);
        c.readObject(s, o);
        return c;
    }
    
    public void readObject(IStream s, ObjectManager o) throws java.io.IOException {        
        data.active = s.readByte("Active");
        data.address = s.readByte("Address");
        data.target = s.readByte("Target");
        
        options = (ChipOptions)o.readObject(s, "ChipOptions", "SctData.ChipOptions");
        data.basic.config = options.getData();
        
        setThreshold(s.readByte("Threshold"));
        setCalCharge(s.readByte("CalCharge"));
        setStrobeDelay(s.readByte("Delay"));
        data.basic.preamp = s.readByte("Preamp");
        data.basic.shaper = s.readByte("Shaper");
        
        data.basic.mask = s.readIntArray("Masks");
        
        data.caldata.rc_function = s.readByte("RcFunction");
        data.caldata.rc_params = s.readFloatArray("RcParams");
        data.caldata.c_factor = s.readFloat("CalFactor");
        
        data.trim = s.readByteArray("Trims");        
    }
    
    public void write(OStream s, ObjectManager o) throws java.io.IOException {        
        s.writeByte("Active", data.active, false);
        s.writeByte("Address", data.address, false);
        s.writeByte("Target", data.target, false);        
        
        o.writeObject(s, "ChipOptions", options, false);
        
        s.writeByte("Threshold", getThreshold(), false);
        s.writeByte("CalCharge", getCalCharge(), false);
        s.writeByte("Delay", getStrobeDelay(), false);
        s.writeByte("Preamp", data.basic.preamp, false);
        s.writeByte("Shaper", data.basic.shaper, false);
        
        s.writeIntArray("Masks", data.basic.mask, false);
        
        s.writeByte("RcFunction", data.caldata.rc_function, false);
        s.writeFloatArray("RcParams", data.caldata.rc_params);
        s.writeFloat("CalFactor", data.caldata.c_factor);
        
        s.writeByteArray("Trims", data.trim, false);
    }
    
    //Data
    ABCDChip data;
    ChipOptions options;
}

---