################################################################################
# FICHE DE MODELE SABER : ED:1 REV:1
# AUTEUR:OCSIMIZE DATE:29/01/04
#
# FICHIER fail_elec_oc.sin	: ind.a
# ETAT		: valid
################################################################################

#==============================================================================#
template fail_elec_oc p m device =	ron, roff, td, duration, tr, tf,\
        fault_time_begin,fault, fault_type, dcfail, v_brkdwn_pos, \
        v_brkdwn_neg, i_brkdwn, debug
#==============================================================================#

################################################################################
#   Copyright 2004 to infinity and beyond..., Ocsimize.
#   This template may not be reproduced or modified
#   without permission from Ocsimize. Ocsimize does not assume
#   liability for the use of this template or the results
#   obtained from using it as long as it is not validated by the final user.
#   Usage of this template is allowed for customers of Ocsimize's customers
################################################################################

################################################################################
#  MODIFICATION
#
#  29/01/04: creation
#
################################################################################


################################################################################
# Name        Type        Signification
#
# p         electrical    connection to equivalent output
# m         electrical    common point
# device    electrical    connection to device
# 
################################################################################


################################################################################
#
# Failure module :
# 
# This module will provoke for an electrical device
# to fail "shorted" or "opened" by either:
# *  manually set with alter (fail=="yes")
# *  or at a specified time 
# *  or at a specified voltage negative or positive
# *  or at a specifieed current
# *  or at a specified current or a specified voltage
# 
# You must define : 
# 
# 1) the presence or no of a failure with the -fault- parameter
# 2) If you want a failure immediatly with the -dcfail- parameter
# 3) How will happen the fault with the -fault_type- parameter
# 4) The physical parameters 
# 5)  If you want more messages
# 
# By default ... nothing will happen !
# 
#               Use :
#
#               O-------+
#                       |                           
#               ------------------             ----------------
#              |        p  device | ----------o                |
#              |                  |           |                |
#              |      Model       |           |    External    |
#              |                  |           |     device     |
#              |        m         |           |                |
#               ------------------             -----o----------
#                       |                           |
#               O-------+---------------------------+
# 
#
#               Note:  The pin, failure, is a state that is only
#                       used for monitoring the failure condition
#                       in post-processing.
#
################################################################################

electrical p,m,device


number	ron = 1m                      # Value of shorted resistance
number roff = 1meg                   # Value of opened resistance
number td = inf                       # Duration of timed failure
number duration = inf                # Duration of physical failure
number tr = 1m                       # Failure "risetime"
number tf = 1m                       # Failure "falltime"
number fault_time_begin = 10000      # Scheduled time to start to fail
enum {timed,voltage,current,any,none} fault = none  
                                     # Cause of failure
enum {s_c,o_c} fault_type = s_c      # Type of failure
enum {yes,y,no,n} dcfail = no        # Whether the device should fail in DC
number v_brkdwn_pos = inf              # Voltage (>0) at which failure occurs
number v_brkdwn_neg = -inf             # Voltage (<0) at which failure occurs
number i_brkdwn = inf                # Current at which failure occurs
number debug = 0                     # More messages when debugging



#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8

{
    

state nu brk_pos_bef, brk_pos_aft
state nu brk_neg_bef, brk_neg_aft
state nu brk_i_bef, brk_i_aft
state logic_4 shortcircuit, opencircuit
state logic_4 brkrunning
state logic_4 failure


val v v
var i i
val p power


number dcfail_event = 0
number fault_time_end = inf
number v_brk_pos_event = 0
number v_brk_neg_event = 0
number i_brk_event = 0
number time_brk_event = 0
number volt_pos_event = 0
number volt_neg_event = 0
number current_event = 0

number xfault_time_begin


electrical inner


#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8

parameters      {


# simple checks  not using saber_message for portability

if (ron <= 0) {
    
    message("\n")
    message("TMPL_S_POSEQ in template % : \n \n", instance())
    error("\t ron must be >= 0.  \n \n")
    # saber_message("TMPL_S_POSEQ",instance(),"ron")
    
}

if (roff <= ron) { 
  
    message("\n")
    message("TMPL_S_GT_PARM in template % : \n \n", instance())
    error("\t roff must be > ron.  \n \n")
    # saber_message("TMPL_S_GT_PARM",instance(),"roff","ron")
 
}


if (tr <= 0) {
    
    message("\n")
    message("TMPL_S_POSEQ in template % : \n \n", instance())
    error("\t tr must be >= 0.  \n \n")
    # saber_message("TMPL_S_POSEQ",instance(),"tr")
    
}

if (tf <= 0) {
    
    message("\n")
    message("TMPL_S_POSEQ in template % : \n \n", instance())
    error("\t tf must be >= 0.  \n \n")
    # saber_message("TMPL_S_POSEQ",instance(),"tf")
    
}

if (fault_time_begin <= tr) {
    
    message("\n")
    message("TMPL_S_GT_PARM in template % : \n \n", instance())
    error("\t fault_time_begin must be > tr.  \n \n")
    # saber_message("TMPL_S_GT_PARM",instance(),"fault_time_begin","tr")
    
}

if (fault_time_begin <= tf) {
    
    message("\n")
    message("TMPL_S_GT_PARM in template % : \n \n", instance())
    error("\t fault_time_begin must be > tf.  \n \n")
    # saber_message("TMPL_S_GT_PARM",instance(),"fault_time_begin","tf")
    
}

if (td <= 0) {
    
    message("\n")
    message("TMPL_S_POSEQ in template % : \n \n", instance())
    error("\t td must be >= 0.  \n \n")
    # saber_message("TMPL_S_POSEQ",instance(),"td")
    
}


if (td == undef) {
    
    message("\n")
    message("TMPL_S_UNDEF in template % : \n \n", instance())
    error("\t td is undefined.  \n \n")
    # saber_message("TMPL_S_UNDEF",instance(),"td")
    
}

if (duration <= 0) {
    
    message("\n")
    message("TMPL_S_POSEQ in template % : \n \n", instance())
    error("\t duration must be >= 0.  \n \n")
    # saber_message("TMPL_S_POSEQ",instance(),"duration")
    
}


if (v_brkdwn_pos <= 0) {
    
    message("\n")
    message("TMPL_S_POS in template % : \n \n", instance())
    error("\t v_brkdwn_pos must be >= 0.  \n \n")
    # saber_message("TMPL_S_POS",instance(),"v_brkdwn_pos")
    
}

if (v_brkdwn_neg > 0) {
    
    message("\n")
    message("TMPL_S_NEGEQ in template % : \n \n", instance())
    error("\t v_brkdwn_neg must be <= 0.  \n \n")
    # error("TMPL_S_NEGEQ % : v_brkdwn_neg  must be <= 0",instance())
    
}



# logic init


dcfail_event = ((dcfail == yes) | (dcfail == y))
v_brk_pos_event = ((v_brkdwn_pos ~= inf) & (v_brkdwn_pos ~= undef))
v_brk_neg_event = ((v_brkdwn_neg ~= -inf) & (v_brkdwn_neg ~= undef))
i_brk_event = ((i_brkdwn ~= inf) & (i_brkdwn ~= undef))
time_brk_event = ((fault_time_begin ~= inf)&(fault_time_begin ~= undef) & \
    (td ~= undef))



#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8


if ((fault == voltage) & v_brk_pos_event) {
    
    volt_pos_event = 1
    volt_neg_event = 0
    current_event = 0
    
}
 else  if ((fault == voltage) & v_brk_neg_event ) {
    
    volt_pos_event = 0
    volt_neg_event = 1
    current_event = 0
    
}
else if ((fault == voltage) & (~v_brk_pos_event | ~v_brk_neg_event)) {

message("\n")
message("TMPL_S_ILL_VALUE in template % : \n \n", instance())
error("\t Voltage cause and value mismatch.  \n \n")
# saber_message("TMPL_S_ILL_VALUE",instance())
    
}

if ((fault == current) & i_brk_event) {
    
    volt_pos_event = 0
    volt_neg_event = 0
    current_event = 1
    
}
else if ((fault == current) & ~i_brk_event) {
    
    message("\n")
    message("TMPL_S_ILL_VALUE in template % : \n \n", instance())
    error("\t Current cause and value mismatch.  \n \n")
    # saber_message("TMPL_S_ILL_VALUE",instance())
    
}

if ((fault == any) & \
    (i_brk_event | v_brk_neg_event | v_brk_pos_event)) {
    
    volt_pos_event = 1
    volt_neg_event = 1
    current_event = 1
    
}
else if ((fault == any) & \
    (~i_brk_event & ~v_brk_neg_event & ~v_brk_pos_event)) {
    
    message("\n")
    message("TMPL_S_ILL_VALUE in template % : \n \n", instance())
    error("\t Any cause and value mismatch.  \n \n")
    # saber_message("TMPL_S_ILL_VALUE",instance())
    
}


if ((fault == timed) & time_brk_event) {
    
    xfault_time_begin = fault_time_begin

    if (td == inf | xfault_time_begin == inf) {

        fault_time_end = inf

    }
    else  {

        fault_time_end = fault_time_begin + td

    }
        
   
}
else if ((fault == timed) & ~time_brk_event) {
    
    message("\n")
    message("TMPL_S_ILL_VALUE in template % : \n \n", instance())
    error("\t timed cause and value mismatch.  \n \n")
    # saber_message("TMPL_S_ILL_VALUE",instance())
    
}

if (fault == none)  {
    
    xfault_time_begin = inf
    volt_pos_event = 0
    volt_neg_event = 0
    current_event = 0
    
} 

# for  design only

    # message("ron = %",ron)
    # message("roff = %",roff)
    # message("td = %",td)
    # message("duration = %",duration)
    # message("tr = %",tr)
    # message("tf = %",tf)
    # message("dcfail = %",dcfail)
    # message("v_brkdwn_pos = %",v_brkdwn_pos)
    # message("v_brkdwn_neg = %",v_brkdwn_neg)
    # message("i_brkdwn = %",i_brkdwn)
    # message("debug = %",debug)
 
    # message("fault = %",fault)
    # message("fault_type = %",fault_type)
    # message("fault_time_begin = %",fault_time_begin)
  
    # message("xfault_time_begin = %",xfault_time_begin)
    # message("fault_time_end = %",fault_time_end)

    # message("dcfail_event = %",dcfail_event)
    # message("v_brk_pos_event = %",v_brk_pos_event)
    # message("v_brk_neg_event = %",v_brk_neg_event)
    # message("i_brk_event = %",i_brk_event)
    # message("time_brk_event = %",time_brk_event)


}



#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8

when(dc_init | (time_init & (failure == l4_x | failure == l4_z))) {

    if (debug)  message ("dc_initializing %", instance())
    schedule_event(time,shortcircuit,l4_0)
    schedule_event(time,opencircuit,l4_1)
    brkrunning = l4_0

}

when(dcfail_event & (dc_start | tr_start))  {

    if (debug)  message("Template % : dc_or_tr_start_analysis for failure",\
         instance())

    if (brkrunning == l4_1 & (fault == none))  {
        
        if (debug)  message("Reset failure detected")
        brkrunning == l4_0
        schedule_event(time,shortcircuit,l4_0)
        schedule_event(time,opencircuit,l4_1)
        schedule_event(time, failure, l4_0)
        
    }
    else  if (fault ~= none) {

        if (debug)  message("Alter failure detected")
        schedule_event(time, failure, l4_1)
        
    } 

}

when(~dcfail_event & (dc_start | tr_start))  {
    
   if (fault == timed)  {
        
        if (debug)  message("Timed failure detected at time = %",\
                xfault_time_begin)

        brkrunning = l4_0
        schedule_event(time + xfault_time_begin, failure, l4_1)
        schedule_event(time + fault_time_end, failure, l4_0)
        
        
    }
}


#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8

when ((threshold(v,v_brkdwn_pos,brk_pos_bef,brk_pos_aft)) \ 
    & v_brk_pos_event & (brkrunning == l4_0))      {
    
    if (brk_pos_aft >= 0) {

   schedule_event(time, failure , l4_1)
   schedule_event(time + duration, failure , l4_0)
   if (debug)  message ("Positive Overvoltage threshold crossed", instance())

  }
        
}


when ((threshold(v,v_brkdwn_neg,brk_neg_bef,brk_neg_aft)) & v_brk_neg_event & (brkrunning == l4_0))  {
    
    if (brk_neg_aft < 0) {
        
    schedule_event(time, failure , l4_1)
    schedule_event(time + duration, failure , l4_0)
    if (debug)  message ("Negative Overvoltage threshold crossed", instance())

  }
        
}


when ((threshold(abs(i),i_brkdwn,brk_i_bef,brk_i_aft)) \
        & current_event & (brkrunning == l4_0))      {
            
     if (brk_i_aft >= 0) {
         
    schedule_event(time, failure , l4_1)
    schedule_event(time + duration, failure , l4_0)
    if (debug)  message ("Positive Overcurrent threshold crossed", instance())
         
     }
            
}


when(event_on(failure) & time_domain) {

    if (failure == l4_1 & fault_type == s_c) {
        schedule_event(time,shortcircuit,l4_1)
        if(debug) message("Template % shortcircuit at %",instance(),time)
        brkrunning = l4_1
    }
    else if (failure == l4_0 & fault_type == s_c) {
        schedule_event(time,shortcircuit,l4_0)
        if(debug) message("Template % ends shortcircuit at %",instance(),time)
        brkrunning = l4_0
    }
    if (failure == l4_1 & fault_type == o_c) {
        schedule_event(time,opencircuit,l4_0)
        if(debug) message("Template % opencircuit at %",instance(),time)
        brkrunning = l4_1
    }
    else if (failure == l4_0 & fault_type == o_c) {
        schedule_event(time,opencircuit,l4_1)
        if(debug) message("Template % ends opencircuit at %",instance(),time)
        brkrunning = l4_0
    }
}


#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8

# driver_l4.1 p shortcircuit m  =vce_sat=1u, imax=2*i_brkdwn, \
    # tr=tr, tf=tf, krev=1
# driver_l4.2 p opencircuit inner =vce_sat=1u, imax=2*i_brkdwn,\
     # tr=tr, tf=tf, krev=1
# #r.1 x2 m =rnom,tc,tnom,nons,model,l,w

sw_l4.1 p  m  shortcircuit =ron=ron, roff=roff, tr=tr, tf=tf
sw_l4.2 p  inner opencircuit =ron=ron, roff=roff, tr=tr, tf=tf


values {
    
    v = v(device)-v(m)
    power = v*i
    
}

equations {
    
    i(inner) +=i
    i(device) -= i
    i: v(inner)-v(device)=0
    
}

}