RELATIONS ENTRE LES DIFFÉRENTES TABLES

NOTIONS LIÉS À LA STRUCTURE

Chaque alimentation est répérée par son type et un numéro de série et c'est ce couple qui repére de façon unique une alimentation.

Le nom opérationnel est attribué lors de l'installation (déplacement ou création d'alimentation) et doit aussi être unique pour les alimentations en activité (alim.located.date_ol_unloc IS NULL).

Il ne faut pas confondre un type d'alimentation et une alimentation (qui doit être d'un certain type)

Il ne faut pas confondre un type d'alimentation et une famille. Plusieurs type d'alimentation peuvent être de la même famille, ce champ permet de regrouper les alimentations ayant les mêmes genres de caractéristiques, de plus ce champ doit absolument être rempli lors de la création d'un nouveau type.
 
Toutes les alimentations en activités dans la table alim.located ont un enregistrements associé dans la table alim.all_characteristics pour détailler les particularités de l'alim. Suivant la famille de l'alim les champs de alim.all_characteristics changent de nature. Voir les view associées : alim_characteristics_sps, alim.characteristics_lep, alim.characteristics_area

La description de tous les composants est mise dans la table alim.all_components. Donc la nature de chaque champ à une signification différente selon s'il s'agit d'un MCB ou d'un Transfo, Le champ type permet de savoir de quel type de composant il s'agit de façon à lui associer les bonne définitions. Voir les view associées : alim.component_mcb, alim.component_transducer, alim.component_transformer, alim_component_fan, alim_component_crate

DEFINITION DES TABLES

CREATE TABLE located
(
   part_type1 VARCHAR2(15) NOT NULL, // Type d'alimentation
   id_number1 VARCHAR2(10) NOT NULL, // Numéro de série de l'alimentation
   date_loc DATE DEFAULT SYSDATE NOT NULL, //Date d'installation à cet endroit
   date_of_unloc DATE, //Date de désinstallation de cet endroit
   id_building NUMBER(3) DEFAULT 0, // Référence du batiment dans lequel l'alim est installée
   logical_name VARCHAR2(10) DEFAULT 'none' , // Nom d'installation de l'alimentation
   status VARCHAR2(20) DEFAULT 'Installed', // Status (Installed,Spare et Spare-Installed)
   id_machine NUMBER(2) DEFAULT 0, //Référence de la machine dans laquelle est installé l'alimentation
   comments  VARCHAR2(80),
   emd VARCHAR2(15),//départ électrique
   erd VARCHAR2(15),// départ électrique
   position VARCHAR2(15),//position précise dans le batiment

   CONSTRAINT pk_located PRIMARY KEY (part_type1,id_number1,date_loc)
)
Cette table contient les données d'installation de toutes les alimentations ainsi que l'historique de leurs mouvements.
Une alimentation (physique) est définie par sont type plus un numéro de série.
il faut donc que part-type1 existe dans la la table alim.pc.part_type avant de créer une nouvelle alimentation.
Si le champ date_of_unloc est nul alors il s'agit de la dernière installation d'une alimentation sinon ce sont des données historiques des mouvements des alimentations.
id_building et id_machine doivent exister dans les vues alim.building et alim.machine.

CREATE TABLE pc
(
   part_type         VARCHAR2(15),//Type de l'équipment
   id_Family  NUMBER(2) DEFAULT 0,//Famille de l'équipment voir table ALIM.LIST avec Type='FAMILY'
   manufacturer     VARCHAR2(20),//Fabricant
   uac                   NUMBER(10,3),//Tension nominale d'alimentation primaire
   iac                    NUMBER(10,3),//Courant nominale d'alimentation primaire
   vmax                NUMBER(10,3),//Tension maximum de sortie
   imax                 NUMBER(10,3),//Courant maximum de sortie
   irms                  NUMBER(10,3),//Courant efficace
   id_polarity NUMBER(2) DEFAULT 0,//Polarité voir table ALIM.LIST avec Type='POLARITY'
   id_topology NUMBER(2) DEFAULT 0,//Topologie (principe de fonctionnement) voir table ALIM.LIST avec Type='TOPOLOGY'
   precision          NUMBER(10,3),
   active_filter NUMBER(1) DEFAULT 0,//0 =>pas de filtre actif et -1 => avec filtre actif
   dimensions       VARCHAR2(30),//dimensions en principe(largeurxprofondeurxhauteur)
   weight              NUMBER(10,3),//poids en kilo
   remarks           VARCHAR2(150),
   coef_dissip NUMBER(4,3) DEFAULT 1,//coefficient de dissipation

   CONSTRAINT pk_pc PRIMARY KEY (part_type)
)
Cette table contient les données communes à un type d'alimentation ainsi que sa famille qui est très importante pour pouvoir retrouver les données particulières à une famille d'alimentation.
En effet toutes les caractéristiques non communes à tous les types d'alimentations sont gérées séparemment par la table alim.all_characterisitics et suivant la famille on utilise des vues particulières de alim.all_characteristics (alim.characteristics_areas, alim.characteristics_sps, alim.characteristics_lep, ...). Mais cette table n'est pas organisée par type d'alimentation mais par alimentation, c'est à dire que chaque alimentation peut avoir des données différentes même si elles sont de même type.

CREATE TABLE all_characteristics
(
part_type varchar2(15),
id_number varchar2(10),
s10_1 varchar2(10),
s10_2 varchar2(10),
s10_3 varchar2(10),
s10_4 varchar2(10),
s10_5 varchar2(10),
s10_6 varchar2(10),
s10_7 varchar2(10),
s10_8 varchar2(10),
s10_9 varchar2(10),
s10_10 varchar2(10),
s10_11 varchar2(10),
s10_12 varchar2(10),
s10_13 varchar2(10),
s10_14 varchar2(10),
s10_15 varchar2(10),
s10_16 varchar2(10),
s10_17 varchar2(10),
s10_18 varchar2(10),
s10_19 varchar2(10),
s10_20 varchar2(10),
s10_21 varchar2(10),
s10_22 varchar2(10),
s10_23 varchar2(10),
s10_24 varchar2(10),
s10_25 varchar2(10),
s10_26 varchar2(10),
s10_27 varchar2(10),
s10_28 varchar2(10),
s10_29 varchar2(10),
s10_30 varchar2(10),
s10_31 varchar2(10),
s10_32 varchar2(10),
s10_33 varchar2(10),
s10_34 varchar2(10),
s10_35 varchar2(10),
s10_36 varchar2(10),
s10_37 varchar2(10),
s10_38 varchar2(10),
s10_39 varchar2(10),
s10_40 varchar2(10),
s20_1 varchar2(20),
s20_2 varchar2(20),
s20_3 varchar2(20),
s20_4 varchar2(20),
s20_5 varchar2(20),
s20_6 varchar2(20),
s20_7 varchar2(20),
s20_8 varchar2(20),
s20_9 varchar2(20),
s20_10 varchar2(20),
s30_1 varchar2(30),
s30_2 varchar2(30),
s30_3 varchar2(30),
s30_4 varchar2(30),
s30_5 varchar2(30),
s150_1 varchar2(150),
I1 number(5),
I2 number(5),
I3 number(5),
I4 number(5),
I5 number(5),
I6 number(5),
I7 number(5),
I8 number(5),
I9 number(5),
I10 number(5),
I11 number(5),
I12 number(5),
D1 number(10,3),
D2 number(10,3),
D3 number(10,3),
D4 number(10,3),
D5 number(10,3),
D6 number(10,3),
D7 number(10,3),
D8 number(10,3),
D9 number(10,3),
D10 number(10,3),
D11 number(10,3),
D12 number(10,3),

CONSTRAINT pk_all_characteristics PRIMARY KEY(part_type,id_number)
)

Cette table contient les données particulières de toutes les différentes famille d'alimentation. Suivant la famille la fonction de ces champs change.
En effet toutes les caractéristiques non communes à tous les types d'alimentations sont gérées séparemment par la table alim.all_characterisitics et suivant la famille on utilise des vues particulières de alim.all_characteristics (alim.characteristics_areas, alim.characteristics_sps, alim.characteristics_lep, ...). Mais cette table n'est pas organisée par type d'alimentation mais par alimentation, c'est à dire que chaque alimentation peut avoir des données différentes même si elles sont de même type.
Ci-dessous la liste des vues issues de cette table définissant les différents champs en fonction de la famille:

CREATE VIEW Characteristics_Areas AS SELECT
      Part_Type,ID_Number,
      D1 AS maximum,
      D10 AS cable_value,
      D11 AS tolerance,
      D3 as Dcct_Eqp_1,
      D4 as Dcct_Eqp_2,
      D5 as Dcct_Eqp_3,
      D6 as Dcct_Con_1,
      D7 as Dcct_Con_2,
      D8 as Dcct_Con_3,
      D9 AS Dcct_Ad4,
      I1 AS eqp_number,
      I10 AS Low_Beta,
      I11 AS ID_pulse,
      I12 AS alarm,
      I2 AS converter,
      I3 AS ad2,
      I4 AS ad3,
      I5 AS ad4,
      I6 AS interlock,
      I7 AS P0_Survey,
      I8 AS Spectrometer,
      I9 AS Modified,
      S10_10 AS rxn_high,
      S10_11 AS rxn_low,
      S10_12 AS lrd,
      S10_13 AS ltb,
      S10_14 AS Manifold,
      S150_1 AS remarks
FROM Alim.All_Characteristics;

CREATE OR REPLACE VIEW Characteristics_Lep AS SELECT
  Part_Type,ID_Number,
  D1 AS L_List,
  D10 AS I_Max_List,
  D11 AS V_Max_List,
  D11/D10 AS R_List,
  D12 AS fuse,
  I1 AS BC,
  I10 AS RT,
  I11 AS ID_COMPUTER,
  S10_10 AS pr22,
  S10_11 AS pr26,
  S10_12 AS pr33,
  S10_13 AS pr34,
  S10_14 AS pr60,
  S10_15 AS pr85,
  S10_16 AS pr100,
  S10_17 AS cr23,
  S10_18 AS cr24,
  S10_19 AS cr25,
  S10_2 AS cr28,
  S10_20 AS lr40,
  S10_21 AS lr34,
  S10_22 AS lr41,
  S10_23 AS lr43,
  S10_24 AS lc10,
  S10_25 AS lc11,
  S10_26 AS lc12,
  S10_27 AS lc13,
  S10_28 AS lr25,
  S10_29 AS lc5,
  S10_3 AS lr30,
  S10_30 AS lc9,
  S10_31 AS lr109,
  S10_32 AS lr111,
  S10_33 AS lr11,
  S10_34 AS lr102,
  S10_35 AS lr103,
  S10_36 AS lr22,
  S10_37 AS lr19,
  S10_38 AS lr96,
  S10_39 AS lr28,
  S10_4 AS lc7,
  S10_40 AS lr167,
  S10_5 AS lr152,
  S10_6 AS lc42,
  S10_7 AS lr168,
  S10_8 AS lr151,
  S10_9 AS lc43,
  S150_1 AS remarks,
  S20_1 AS configuration,
  S20_10 AS configurateur_type
FROM ALIM.ALL_CHARACTERISTICS;
 

CREATE OR REPLACE VIEW Characteristics_LepA AS SELECT
  Part_Type,ID_Number,
  alim.Give_IMax(Part_Type) AS Imax,
  alim.Give_Vmax(Part_Type) AS Vmax,
  D1 AS I_List,
  D2 AS R_Load,
  D3 AS L_Load,
  D1*D2 AS U_Load_total,
  D1*D2/4 AS U_Load_conv,
  D4 AS fuse,
  I1 AS ID_Configuration,
  I2 AS BC,
  I3 AS RT,
  I4 AS ID_Computer,
  S10_1 AS pr26,
  S10_2 AS pr33,
  S10_3 AS pr34,
  S10_4 AS lr28,
  S10_5 AS lr40,
  S10_6 AS lr41,
  S10_7 AS lc11,
  S10_8 AS lc13,
  S10_9 AS lr30,
  S10_10 AS lc9,
  S10_11 AS lr11,
  S10_12 AS lc7,
  S10_13 AS lr167,
  S10_14 AS lr152,
  S10_15 AS lc42,
  S10_16 AS lr168,
  S10_17 AS lr151,
  S10_18 AS lc43,
  S150_1 AS remarks,
  S20_1 AS configurateur_type
FROM ALIM.ALL_CHARACTERISTICS;
 
CREATE OR REPLACE VIEW Characteristics_LepB AS SELECT
  Part_Type,ID_Number,
  alim.Give_IMax(Part_Type) AS Imax,
  alim.Give_Vmax(Part_Type) AS Vmax,
  alim.Give_IMax(Part_Type)*2 AS Imax_Parallel,
  alim.Give_VMax(Part_Type)/2 AS Vmax_Parallel,
  D1 AS I_List,
  D2 AS U_Load,
  D2/D1 AS R_Load,
  D3 AS L_Load,
  D4 AS fuse,
  I1 AS ID_Configuration,
  I2 AS BC,
  I3 AS RT,
  I4 AS ID_COMPUTER,
  S10_1 AS pr22,
  S10_2 AS pr60,
  S10_3 AS pr85,
  S10_4 AS pr100,
  S10_5 AS cr23,
  S10_6 AS cr24,
  S10_7 AS cr25,
  S10_8 AS cr28,
  S10_9 AS lr40,
  S10_10 AS lr34,
  S10_11 AS lr43,
  S10_12 AS lc10,
  S10_13 AS lc12,
  S10_14 AS lc13,
  S10_15 AS lr25,
  S10_16 AS lc5,
  S10_17 AS lr30,
  S10_18 AS lc9,
  S10_19 AS lr109,
  S10_20 AS lr111,
  S10_21 AS lr11,
  S10_22 AS lr102,
  S10_23 AS lr103,
  S10_24 AS lr22,
  S150_1 AS remarks,
  S20_1 AS configurateur_type
FROM ALIM.ALL_CHARACTERISTICS;
 

CREATE VIEW Characteristics_Sps AS SELECT
  Part_Type,Id_number,
  D1 AS MCB_magnetique,
  D10 AS L2_af,
  D11 AS Phases_gene_impul,
  D2 AS L2_imax_af,
  D3 AS L1_pf,
  D4 AS C1_pf,
  D5 AS C1_volt_pf,
  D6 AS C2_pf,
  D7 AS C2_volt_pf,
  D8 AS R_pf,
  D9 AS R_type_pf,
  I1 AS nb_pont,
  I10 AS nb_distributeur,
  I11 AS nb_165_isr,
  I12 AS nb_aux_isr,
  I2 As sw1_sw2,
  I3 AS nb_ampli_impul,
  I4 AS bloc_impul,
  I5 AS delay,
  I6 AS nb_15,
  I7 AS nb_6_5,
  I8 AS nb_15_30,
  I9 AS nb_15_60,
  S10_1 AS L2_cooling_af,
  S10_10 AS ratio_af,
  S10_11 AS L1_cooling_pf,
  S10_12 AS r59_el,
  S10_13 AS r27_pc,
  S10_14 AS r24_pc,
  S10_15 AS r25_pc,
  S10_16 AS r29_pc,
  S10_17 AS r1_vl,
  S10_18 AS r2_vl,
  S10_19 AS r3_vl,
  S10_2 AS r4_vl,
  S10_20 AS r5_vl,
  S10_21 AS r6_vl,
  S10_22 AS r7_vl,
  S10_23 AS r8_vl,
  S10_24 AS r9_vl,
  S10_25 AS r10_vl,
  S10_26 AS r11_vl,
  S10_27 AS r12_vl,
  S10_28 AS r13_vl,
  S10_29 AS c1_vl,
  S10_3 AS c2_vl,
  S10_30 AS c4_vl,
  S10_31 AS r36_cr,
  S10_32 AS r37_cr,
  S10_33 AS r74_cr,
  S10_34 AS r75_cr,
  S10_35 AS r76_cr,
  S10_36 AS p4_cr,
  S10_37 AS c3_cr,
  S10_38 AS c11_cr,
  S10_39 AS preampli_type,
  S10_4 AS loop_change_over,
  S10_40 AS photo,
  S10_5 AS cur_bal,
  S10_6 AS spark_gap,
  S10_7 AS over_current,
  S10_8 AS mcb_thermique,
  S150_1 AS remarks,
  S20_1 AS cooling,
  S20_10 AS protection,
  S20_2 AS thyristor,
  S20_3 AS diode,
  S20_4 AS transfo_af,
  S20_5 AS alim_af,
  S20_6 AS ampli_af,
  S20_7 AS voltage_loop_type,
  S20_8 AS current_regulator_type,
  S30_1 AS schema,
  S30_2 AS cycle,
  S30_3 AS C1_comp_pf,
  S30_4 AS C2_comp_pf,
  S30_5 AS R_comp_pf
FROM Alim.All_Characteristics;

CREATE TABLE beam_magnet
(
   part_type VARCHAR2(15) NOT NULL,
   id_number VARCHAR2(10) NOT NULL,
   magnet_name VARCHAR2(10)  DEFAULT 'UNKNOWN' NOT NULL,
   position VARCHAR2(10)  DEFAULT '0',
   id_beam NUMBER(2) DEFAULT 0,
   magnet_type VARCHAR2(10)  DEFAULT 'UNKNOWN',
   id_magnet_area NUMBER(2) DEFAULT 0,
   id_Polarity NUMBER(1) DEFAULT 0,
   remark VARCHAR2(50),
CONSTRAINT pk_beam_magnet PRIMARY KEY (part_type,id_number,magnet_name,magnet_type,position,id_beam)
)

Liste des aimants d'une alimentation avec leur faisceau leur polarité et leur position dans le faisceau.
Cette partie devrait être couverte par le projet CESAR.

CREATE TABLE beam_areas
(
   part_type         VARCHAR2(15)                      NOT NULL,
   id_number         VARCHAR2(10)                      NOT NULL,
   id_beam            NUMBER(2)                         DEFAULT 0,
   id_pulse           NUMBER(1)                         DEFAULT 0,
   P0_Survey          NUMBER(1)                         DEFAULT 0,

   CONSTRAINT pk_beam_areas PRIMARY KEY (part_type,id_number,id_beam)
)

Liste des spécificités par faisceau des redresseurs. Alims toujours pulsé ou toujours DC ou faisant partie de la surveillance de P0. Cette partie devrait être couverte par le projet CESAR

CREATE TABLE magnet
(
   magnet_type      VARCHAR2(10)    NOT NULL,
   inductance            NUMBER(10,3)    DEFAULT 0, //Inductance en Henry
   resistance             NUMBER(10,3)    DEFAULT 0, //Résistance en Ohm
   Imax                    NUMBER(5)         DEFAULT 0, // Courant maximum admis par l'aimant
   Flow                    NUMBER(10,3)    DEFAULT 0,
   Delta_P                NUMBER(3)         DEFAULT 0,
   DC                      NUMBER(1)          DEFAULT 0,//Aimant uniquement en DC=-1 sinon 0
   CONSTRAINT pk_magnet PRIMARY KEY (magnet_type)
     )
/

Caractéristiques des aimants. Cette partie devrait provenir du groupe aimant.

CREATE TABLE Component
(
 part_type VARCHAR2(15),//type de l'alim contenant le composant
 id_number VARCHAR2(10),//numéro de série de l'alim contenant le composant
 part_type2 VARCHAR2(15),//type du composant
 date_loc DATE DEFAULT sysdate,//Date d'installation du composant
 DATE_OF_UNLOC DATE,//Date de désinstallation du composant
 QUANTITY  NUMBER(2) DEFAULT 1,//Nombre de composants de ce type installé
 DATE_CHECKUP DATE,
 
 CONSTRAINT pk_Component Primary Key (Part_type,Id_Number,Part_type2,Date_Loc)
)
Liste des composants contenus dans une alimentation (ex: transfo,mcb,dcct,crate,fan...)
On trouve l'historique de l'installation des composants, les derniers composants installés on tous le champ date_of_unloc nul.
Part_type2 doit se trouver dans la table alim.all_components.part_type avant de pouvoir être utiliser dans cette table.

CREATE TABLE All_Components (
part_type                           VARCHAR2(15),
type      NOT NULL          VARCHAR2(15),
F1                                       VARCHAR2(20),
F2                                       VARCHAR2(20),
F3                                       VARCHAR2(20),
F4                                       VARCHAR2(20),
F5                                       VARCHAR2(20),
F6                                       VARCHAR2(20),
F7                                       VARCHAR2(20),
F8                                       VARCHAR2(20),
F9                                       VARCHAR2(20),
F10                                      VARCHAR2(20),
F11                                      VARCHAR2(20),
F12                                      VARCHAR2(20),
F13                                      VARCHAR2(20),
F14                                      VARCHAR2(20),
F15                                      VARCHAR2(20),
F16                                      VARCHAR2(20),
F17                                      VARCHAR2(20),
F18                                      VARCHAR2(20),
F19                                      VARCHAR2(20),
F20                                      VARCHAR2(20),
F21                                      VARCHAR2(20),
F22                                      VARCHAR2(20),
F23                                      VARCHAR2(80),

CONSTRAINT pk_all_components PRIMARY KEY (part_type,type)
)
Caractéristiques de tous les composants confondus
La signification des champs change suivant la nature du composant (champ type)
Ci-dessous les vues particulières à chaque type de composant:

CREATE OR REPLACE VIEW COMPONENT_CRATE AS SELECT
     Part_Type, // Référence de ce type de crate
     Type, //Toujours "CRATE"
     F2 AS ID_Manufacturer,//Fabricant (pas utilisé)
     F23 AS Remarks,
     F3 AS Cards_Number, //nombre de cartes (pas utilisé)
     F4 AS ID_Crate_Type, //type de crate voir table ALIM.LIST avec Type='CRATE TYPE'
     F6 AS Height //Hauteur (pas utilisé)
 FROM ALIM.ALL_COMPONENTS
 WHERE Type='CRATE';
 

CREATE OR REPLACE VIEW COMPONENT_FAN AS SELECT
     Part_Type, //Référence de ce type de ventilateur
     Type, //Toujours "FAN"
     F2 AS Manufacturer,//Fabricant (pas utilisé)
     F23 AS Remarks,
     F4 AS Fan_Type//Type de ventilateur. permet de repérer sur quelle type d'alimentation on peut mettre ce type de ventilateur voir table ALIM.LIST avec Type='FAN TYPE'
 FROM ALIM.ALL_COMPONENTS
 WHERE Type='FAN';
 

CREATE OR REPLACE VIEW COMPONENT_MCB AS SELECT
    Part_Type,//Référence de ce type de MCB
    Type,//Toujours "MCB"
    F10 AS Motor_Voltage,//Tension d'alimentation du moteur
    F11 AS No_Volt_Coil, 
    F2 AS Manufacturer,//Fabricant
    F23 AS Remarks,
    F3 AS Manufacturer_Ref,//Référence du fabricant
    F4 AS MCB_Type,//Type de Mcb
    F6 AS Trip_Unit,//caractéristiques de déclenchement
    F7 AS I_Nominal,//Courant nominal d'utilisation
    F8 AS Assembly,//Principe de montage
    F9 AS Command_Voltage//Tension de commande du moteur
 FROM ALIM.ALL_COMPONENTS
 WHERE Type='MCB';
 

CREATE OR REPLACE VIEW COMPONENT_TRANSDUCER AS SELECT
  Part_Type,//Référence de ce type de Transducer (DCCT)
  Type,//Toujours "TRANSDUCER"
  F10 AS Max_Voltage, //Tension maximum
  F11 AS Polarity,//Polarité
  F12 AS Power_Supply,//tension d'alimentation (pas utilisé)
  F13 AS Primary_Turn,//nombre de tours du primaire
  F14 AS Secondary_Turn,//nombre de tours du secondaire
  F2 AS Manufacturer,//Fabricant
  F23 AS Remarks,
  F3 AS Manufacturer_Ref,//Référence du fabricant
  F4 AS Transducer_Type,//type de dcct
  F5 AS Cooling,//refroidissement (pas utilisé)
  F7 AS Precision,//précision(pas utilisé)
  F8 AS Linearity,//linéarité(pas utilisé)
  F9 AS Max_Current,//Courant maximum qu'il est possible de mesuré
  (F13*10)/(F14*F9) AS Burden,//Valeur de la résistance en Ohm
  F13/F14 AS Coil_Ratio//Rapport en nombre de tours primaire et secondaire
FROM ALIM.ALL_COMPONENTS
WHERE Type='TRANSDUCER';

CREATE OR REPLACE VIEW COMPONENT_TRANSFORMER AS SELECT
  Part_Type,//Référence de ce type de transformateur
  Type,Toujours "TRANSFORMER"
  F10 AS Oil_Weight,//Poids de l'huile en kilo
  F11 AS Primary_Current, //Courant primaire en Ampères
  F12 AS Secondary_Current,//Courant secondaire en Ampères
  F14 AS Primary_Voltage,//Tension primaire en Volts
  F15 AS Secondary_Voltage,//Tension secondaire en Volts
  F16 AS Secondary_Quantity,//Nombre de bobines secondaires
  Alim.Give_Power(F14,F11,3) AS Primary_Power,//Puissance sur le primaire en Watt
  Alim.Give_Power(F15,F12,3) AS Secondary_Power,//Puissance sur le secondaire en Watt
  F17 AS Thermometer,//-1=> équipé d'un thermomètre sinon 0
  F18 AS Thermometer_Type,//Type de thermomètre (généralement température max)
  F19 AS Total_Weight,//Poids total du transfo en kilo (pas utilisé)
  F2 AS Manufacturer,//Fabricant
  F20 AS Vector_Group,//(pas utilisé)
  F21 AS Quantity_Cuve,//(pas utilisé)
  F22 AS Inrush_Current,//(pas utilisé)
  F23 AS Remarks,
  F3 AS Manufacturer_Ref,//Référence du fabricant
  F4 AS Transfo_Type,//type de tranformateur voir table ALIM.LIST avec Type='TRANSFO TYPE'
  F5 AS Cooling,//Type de Refroidissement (pas utilisé)
  F6 AS Gas_Relay,//(pas utilisé)
  F7 AS Gas_Relay_Type,//(pas utilisé)
  F8 AS Oil_Level_Gauge,//(pas utilisé)
  F9 AS Oil_Level_Desc//(pas utilisé)
FROM ALIM.ALL_COMPONENTS
WHERE Type='TRANSFORMER';
 

CREATE TABLE pc_associated
(
part_type1    varchar2(15),//type de l'équipment maitre
id_number1   varchar2(10),//numéro de série del'équipment maitre
part_type2    varchar2(15),//type de l'équipment esclave
id_number2   varchar2(10),//numéro de série de l'équipment esclave
comments       varchar2(50),
type                varchar2(15),//Nature de l'association (DIODE,SERIE,PARALLELE)
CONSTRAINT pk_pc_associated PRIMARY KEY (part_type1,id_number1,part_type2,id_number2)
)
Liste des alimentations sous ensemble d'une autre (redresseurs en série, en parallèle ou diode)

CREATE TABLE list
(
type             NOT NULL   VARCHAR2(30),
name           NOT NULL   VARCHAR2(30),
ind                                      NUMBER(3),
Remarks                                  VARCHAR(50),
CONSTRAINT pk_List PRIMARY KEY (type,name)
)
Données diverses nécéssaires à la base de données (batiments,machines,status,faisceaux,...)
Ci-dessous vues particulières issues de cette table:

CREATE VIEW MACHINE AS SELECT
ind AS id_machine,
name AS machine_name
FROM alim.list WHERE type='MACHINE'

CREATE OR REPLACE VIEW BUILDING AS SELECT
ind AS id_building,
name AS building_name,
Remarks AS Sub_Name
FROM alim.list WHERE type='BUILDING'
 

CREATE VIEW BEAM AS SELECT
ind AS id_beam,
name AS beam_name
FROM alim.list WHERE type='BEAM'

CREATE VIEW STATUS AS SELECT
ind AS id_status,
name AS status_name
FROM alim.list WHERE type='STATUS'

CREATE OR REPLACE VIEW CRATE_MANUFACTURER AS SELECT
     TO_CHAR(Ind) AS ID_manufacturer,
     Name AS Manufacturer,
     Remarks
 FROM ALIM.LIST
 WHERE Type='CRATE MANUFACTURER';

CREATE OR REPLACE VIEW CRATE_TYPE AS SELECT
     TO_CHAR(Ind) AS ID_crate_type,
     Name AS Crate_type,
     Remarks
 FROM ALIM.LIST
 WHERE Type='CRATE TYPE';
 

CREATE TABLE plan
(
   No_plan         VARCHAR2(40),
   title                  VARCHAR2(120)   ,
   comments        VARCHAR2(150)   ,
   created_by      VARCHAR2(40)    ,
   drawer            VARCHAR2(10)    ,
   responsible      VARCHAR2(10)    ,
   old_nb            VARCHAR2(20)    ,
   support           VARCHAR2(10)    ,
   format            VARCHAR2(20)    ,
   id_machine     NUMBER(1)           DEFAULT 0,
   id_building      NUMBER(4)           DEFAULT 0,
   use                 VARCHAR2(20)    ,
   updated          DATE            ,
   finishdate        DATE            ,
   software         VARCHAR2(20)    ,
   id_storage      NUMBER(4)       DEFAULT 0,
   floor               NUMBER(1)       ,
   place              VARCHAR2(10)    ,
   path_autocad  VARCHAR2(100)    ,
   genre              VARCHAR2(10)

   CONSTRAINT pk_plan PRIMARY KEY (no_plan)
)
Liste des données concernant les plans

CREATE TABLE plan_pc
(
   no_plan            VARCHAR2(40),
   type_pc           VARCHAR2(15),

   CONSTRAINT pk_plan_pc PRIMARY KEY (no_plan,type_pc)
)
Relations entre les plans et les types d'alimentation auxquelles appartiennent ces plans

DIFFERENTES FONCTIONS DE LA BASE DE DONNÉES

Give_Name donne le nom correspondant au type et à l'indice donné dans la table alim.list
Utilisation : SELECT alim.give_Name('MACHINE',ind) AS Machine_Name FROM alim.list WHERE type='MACHINE'

CREATE OR REPLACE FUNCTION Give_Name(ListType IN VARCHAR2,ListInd IN NUMBER) RETURN VARCHAR2 IS
ListName VARCHAR2(30);
BEGIN
  SELECT name
  INTO ListName
  FROM alim.list
  WHERE type=ListType AND ind=ListInd;

  RETURN ListName;
 END Give_Name;
/

Give_Yes_No decode la valeur true(-1) en string YES et false (0) en string NO
Utilisation : SELECT part_type,id_number,Give_Yes_No(Alarm) AS Alarme FROM alim.characteristics_areas

CREATE OR REPLACE FUNCTION Give_Yes_No(Var IN NUMBER) RETURN VARCHAR2 IS
YesNo VARCHAR2(10);
BEGIN
  IF Var = -1 THEN
    YesNo := 'YES';
  ELSIF Var = 0 THEN
    YesNo := 'NO';
  ELSE
    YesNo := 'undefined';
  END IF;
  RETURN YesNo;
 END Give_Yes_No;
/

Give_PLS décode l'indice en string compréhensible aux programmes nodal
PD : preferably DC
NP : never pulsed
ND : never DC
PP : preferably pulsed
Permet de générer la colonne PLS du fichier nodal RECTIF.TXT

CREATE OR REPLACE FUNCTION Give_PLS(id IN NUMBER) RETURN VARCHAR2 IS
Pls VARCHAR2(3);
BEGIN
   IF id = 1 THEN
      Pls := 'PD';
   ELSIF id = 2 THEN
       Pls := 'NP';
   ELSIF id = 3 THEN
      Pls := 'ND';
   ELSIF id = 4 THEN
      Pls := 'PP';
   ELSE
      Pls := '';
   END IF;
   RETURN Pls;
END Give_PLS;

Give_Pls_Beam donne le mode pulsé/dc d'une alimentation suivant le faisceau

CREATE OR REPLACE FUNCTION Give_PLS_Beam(PartType IN VARCHAR2,IDNumber IN VARCHAR2,IDBeam IN NUMBER) RETURN VARCHAR2 IS
Pls VARCHAR2(3);
IDPulse NUMBER;
BEGIN
   SELECT Id_Pulse
   INTO IDPulse
   FROM ALIM.BEAM_AREAS
   WHERE Part_type=PartType AND Id_Number=IDNumber AND Id_Beam=IDBeam;
 
  IF IDPulse IS NULL THEN
      Pls := '';
  ELSE
     Pls := alim.Give_Pls(IDPulse);
  END IF;
 
  RETURN Pls;
END Give_PLS_Beam;
/

Give_Jun décode le nom du batiment en numéro valide de junction crate
Permet de générer la colonne JUN du fichier nodal RECTIF.TXT

CREATE OR REPLACE FUNCTION Give_JUN(building IN VARCHAR2) RETURN NUMBER IS
Jun NUMBER;
BEGIN
   IF building = 'BA80' THEN
      Jun := 1;
   ELSIF building = 'BA81' THEN
       Jun := 2;
   ELSIF building = 'BA82' THEN
       Jun := 3;
   ELSIF building = 'WRB1' THEN
       Jun := 4;
   ELSIF building = 'WRB2' THEN
       Jun := 5;
   ELSIF building = 'BA7' THEN
       Jun := 6;
   ELSIF building = 'BLOC3' THEN
       Jun := 8;
   ELSE
      Jun := 0;
   END IF;
   RETURN Jun;
END Give_JUN;
/

Give_P0S_Beam dit si le redresseur est surveillé par "P0 survey" en fonction du faisceau

CREATE OR REPLACE FUNCTION Give_P0S_Beam(PartType IN VARCHAR2,IDNumber IN VARCHAR2,IDBeam IN NUMBER) RETURN NUMBER IS
P0Survey NUMBER;
BEGIN
   SELECT P0_Survey
   INTO P0Survey
   FROM ALIM.BEAM_AREAS
   WHERE Part_type=PartType AND Id_Number=IDNumber AND Id_Beam=IDBeam;
 
  IF P0Survey IS NULL THEN
      P0Survey := 0;
  END IF;
 
  RETURN P0Survey;
END Give_P0S_Beam;
/

Give_DCT renvoie true (-1) ou false (0) pour savoir si l'alimentaion est équipée d'un deuxième dcct ou non.
Dans le paramètre on met la valeur du numéro d'équipement d'un des dcct.
Permet de générer la colonne DCT du fichier nodal RECTIF.TXT

CREATE OR REPLACE FUNCTION Give_DCT(eqp IN number) RETURN NUMBER IS
dct NUMBER;
BEGIN
   IF eqp > 0 THEN
      dct := -1;
   ELSE
      dct := 0;
   END IF;
   RETURN dct;
END Give_dct;
/

Give_Magnet_Name n'est pas utilisée pour le moment

CREATE OR REPLACE FUNCTION Give_Magnet_Name(PartType IN VARCHAR2,IDNumber IN VARCHAR2,IDBeam IN NUMBER,Line IN NUMBER) RETURN VARCHAR2 IS
  RecordCount NUMBER;
  MagnetName VARCHAR2(20);
  CURSOR MagnetCursor IS
    SELECT DISTINCT Magnet_Name
    FROM Alim.Beam_Magnet
    WHERE Part_Type=PartType AND Id_Number=IDNumber AND Id_Beam=IDBeam
    ORDER BY Magnet_Name;
BEGIN
   RecordCount := 0;
   MagnetName := '';
   FOR MagnetRecord IN MagnetCursor LOOP
      RecordCount := RecordCount + 1;
      IF RecordCount = Line THEN
         MagnetName := MagnetRecord.Magnet_Name;
         EXIT;
      END IF;
   END LOOP;
   RETURN MagnetName;
END Give_Magnet_Name;
/

Give_Magnet_Position n'est pas utilisée pour le moment

CREATE OR REPLACE FUNCTION Give_Magnet_Position(PartType IN VARCHAR2,IDNumber IN VARCHAR2,IDBeam IN NUMBER,MagnetNameLine IN NUMBER,MagnetPositionLine IN NUMBER)
RETURN VARCHAR2 IS
  CountMagnetNameLine NUMBER;
  CountMagnetPositionLine NUMBER;
  MagnetName VARCHAR2(10);
  MagnetPosition VARCHAR2(10);
  CURSOR MagnetCursor IS
    SELECT DISTINCT id_beam,Magnet_Name,Position
    FROM Alim.Beam_Magnet
    WHERE Part_Type=PartType AND Id_Number=IDNumber AND Id_Beam=IDBeam
    ORDER BY id_beam,Magnet_Name,Position;
BEGIN
   CountMagnetNameLine := 0;
   CountMagnetPositionLine := 0;
   MagnetName := ' ';
   MagnetPosition := '';
   FOR MagnetRecord IN MagnetCursor LOOP
       IF MagnetName != MagnetRecord.Magnet_Name THEN
         CountMagnetNameLine := CountMagnetNameLine + 1;
         MagnetName := MagnetRecord.Magnet_Name;
         CountMagnetPositionLine := 0;
      END IF;
      CountMagnetPositionLine := CountMagnetPositionLine + 1;
      IF CountMagnetNameLine = MagnetNameLine AND CountMagnetPositionLine=MagnetPositionLine THEN
         MagnetPosition := MagnetRecord.Position;
         EXIT;
      END IF;
   END LOOP;
   RETURN MagnetPosition;
END Give_Magnet_Position;
/

Give_Magnet permet de générer les deux colonnes MG1 et MG2 du fichier nodal RECTIF.TXT
Renvoie les aimants du type demandé (line=1 ou 2) d'une alimentation et d'un faisceau donné.

CREATE OR REPLACE FUNCTION Give_Magnet(PartType IN VARCHAR2,IDNumber IN VARCHAR2,IDBeam IN NUMBER,Line IN INTEGER)
RETURN VARCHAR2 IS
  Magnet VARCHAR2(240);
  MagnetType VARCHAR2(10);
  CountMagnetType INTEGER;
  CountMagnetNumber INTEGER;
  CURSOR MagnetCursor IS
    SELECT DISTINCT id_beam,Magnet_Type,Position
    FROM Alim.Beam_Magnet
    WHERE Part_Type=PartType AND Id_Number=IDNumber AND Id_Beam=IDBeam
    ORDER BY id_beam,Magnet_Type,Position;
BEGIN
   Magnet := '';
   MagnetType := ' ';
   CountMagnetType := 0;
   CountMagnetNumber := 0;
   FOR MagnetRecord IN MagnetCursor LOOP
       IF MagnetType != MagnetRecord.Magnet_Type THEN
          EXIT WHEN CountMagnetType = Line;
          MagnetType := MagnetRecord.Magnet_Type;
          CountMagnetType := CountMagnetType +1;
          CountMagnetNumber := 0;
          Magnet := MagnetType || ' ';
       END IF;
       CountMagnetNumber := CountMagnetNumber + 1;
       IF CountMagnetNumber > 6 THEN
          EXIT WHEN CountMagnetType = Line;
          Magnet := MagnetType || ' ';
          CountMagnetNumber := 0;
          CountMagnetType := CountMagnetType +1;
       END IF;
       Magnet := Magnet || MagnetRecord.Position || ' - ';
   END LOOP;
   IF CountMagnetType != Line THEN
      Magnet := '';
   END IF;
   RETURN Magnet;
END Give_Magnet;
/ 

Give_Number Permet de transformer un string en nombre (remplace la virgule par un point enlève toutes les lettres)

CREATE OR REPLACE FUNCTION Give_Number(MyNumber IN VARCHAR2) RETURN NUMBER IS
Num NUMBER;
BEGIN
  Num:=To_Number(Translate(UPPER(MyNumber),',0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ','.0123456789'));
  IF Num IS NULL THEN
     Num:=0;
  END IF;
  RETURN Num;
  EXCEPTION
    WHEN INVALID_NUMBER OR VALUE_ERROR THEN
       Num:=0;
       RETURN Num;
 END Give_Number;
/

Give_Power Donne la puissance en KW en fonction de la tension et du courant (P=U*I*sqr(Power))

CREATE OR REPLACE FUNCTION Give_Power(U IN VARCHAR2,I IN VARCHAR2,Power IN NUMBER) RETURN NUMBER IS
Num NUMBER;
BEGIN
  Num:=0;
  Num:=Alim.Give_Number(U)*Alim.Give_Number(I)*SQRT(Power)/1000;

  RETURN Num;
 END Give_Power;
/

Give_MCB_I_Nominal Donne le courant nominal du premier MCB d'une alim
CREATE OR REPLACE FUNCTION Give_MCB_I_Nominal(PartType IN VARCHAR2,IDNumber IN VARCHAR2) RETURN NUMBER IS
Inom VARCHAR2(20);
MyVar NUMBER;
BEGIN
  SELECT DISTINCT Alim.Component_MCB.I_Nominal
  INTO Inom
  FROM Alim.Component,Alim.Component_MCB
  WHERE Alim.Component.Part_Type2=Alim.Component_MCB.Part_Type AND
        Alim.Component.Part_Type=PartType AND Alim.Component.ID_Number=IDNumber AND
        Alim.Component.Date_of_unloc IS NULL;
  IF Inom IS NULL THEN
     MyVar:=0;
  ELSE
     MyVar:=To_Number(Translate(UPPER(Inom),',0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ','.0123456789'));
  END IF;
  RETURN MyVar;
  EXCEPTION
    WHEN INVALID_NUMBER OR VALUE_ERROR THEN
       MyVar:=0;
       RETURN MyVar;
END Give_MCB_I_Nominal;
/
 

Give_Imax Renvoie la valuer de courant maxi d'un type de convertisseur.
CREATE OR REPLACE FUNCTION Give_Imax(PartType IN VARCHAR2) RETURN NUMBER IS
Imax NUMBER;
BEGIN
  SELECT Imax
  INTO Imax
  FROM alim.pc
  WHERE Part_Type=PartType;
  IF Imax IS NULL Then
    Imax:=0;
  END IF;
  RETURN Imax;
 END Give_Imax;
/

Give_Vmax Renvoie la valuer de tension maxi d'un type de convertisseur.
CREATE OR REPLACE FUNCTION Give_Vmax(PartType IN VARCHAR2) RETURN NUMBER IS
Vmax NUMBER;
BEGIN
  SELECT Vmax
  INTO Vmax
  FROM alim.pc
  WHERE Part_Type=PartType;
  IF Vmax IS NULL Then
    Vmax:=0;
  END IF;
  RETURN Vmax;
 END Give_Vmax;
/
 

Lep_Control_Value Renvoie les valuers de BC, RT et COMPUTER (suivant la valeur du paramètre Sort) controlant une alimentation.
CREATE OR REPLACE FUNCTION Lep_Control_Value(PartType IN VARCHAR2,IDNumber IN VARCHAR2,Sort IN VARCHAR2) RETURN VARCHAR2 IS
  Val VARCHAR2(32);
  Family VARCHAR2(32);
  Member VARCHAR2(10);
  Logical VARCHAR2(10);
  BC VARCHAR2(10);
  RT VARCHAR2(10);
  Computer VARCHAR2(32);
BEGIN
   Val := '';
   Logical := alim.Give_Logical_Name(PartType,IdNumber);
   IF Logical IS NOT NULL THEN
     Family := SUBSTR(Logical,1,2);
     Member := SUBSTR(Logical,3,LENGTH(Logical)-2);
     SELECT DISTINCT Host_Name,Field_5,Field_6
     INTO Computer,BC,RT
     FROM SlEquip.mem
     WHERE Fam_Name=Family AND Mem_Number=Member;
     IF Sort = 'BC' THEN
       Val := BC;
     END IF;
     IF Sort = 'RT' THEN
       Val := RT;
     END IF;
     IF Sort = 'COMPUTER' THEN
       Val := Computer;
     END IF;
   END IF;
RETURN Val;
END Lep_Control_Value;
/

Lep_Degauss_Value Renvoie les valeurs de IMIN, IMAX et NB_CYCLES (suivant la valeur du paramètre Sort) de démagnétisation utilisés par une alimentation.
CREATE OR REPLACE FUNCTION Lep_Degauss_Value(PartType IN VARCHAR2,IDNumber IN VARCHAR2,Sort IN VARCHAR2) RETURN NUMBER IS
  Val NUMBER;
  Family VARCHAR2(32);
  Member VARCHAR2(10);
  Logical VARCHAR2(10);
  NbCycles NUMBER;
  Imin NUMBER;
  Imax NUMBER;
  CURSOR DegaussCursor IS
     SELECT DISTINCT Nb_of_Cycles, Imin, Imax
     FROM Control.Cycles,Control.Magnet_Families
     WHERE Cycles.CYCLE_ID = Magnet_Families.Cycle_ID
     AND Pc_Name=Logical;

BEGIN
   Val := 0;
   NbCycles := 0;
   Imin := 0;
   Imax := 0;
   Logical := alim.Give_Logical_Name(PartType,IdNumber);
   IF Logical IS NOT NULL THEN
      Family := SUBSTR(Logical,1,2);
      Member := SUBSTR(Logical,3,LENGTH(Logical)-2);
      FOR DegaussRecord IN DegaussCursor LOOP
         IF Sort = 'NB_CYCLES' THEN
            Val := DegaussRecord.Nb_Of_Cycles;
         END IF;
         IF Sort = 'IMIN' THEN
            Val := DegaussRecord.Imin;
         END IF;
         IF Sort = 'IMAX' THEN
            Val := DegaussRecord.Imax;
         END IF;
      END LOOP;
   END IF;
RETURN Val;
END Lep_Degauss_Value;
/

Give_Tunnel_Order La position d'un aimant (pour les zônes expérimentales) contient dans les trois premiers chiffre le tunnel. Or pour repesenter les layout dans l'ordre d'implantation des aimants il existe une association entre tunnel et ordre dans la table list avec le type 'MAGNET_TUNNEL'
CREATE OR REPLACE FUNCTION Give_Tunnel_Order(Location IN VARCHAR2) RETURN NUMBER IS
Order NUMBER;
BEGIN
  SELECT ind
  INTO Order
  FROM alim.list
  WHERE type='MAGNET_TUNNEL' AND name=substr(Location1,3);

  RETURN Order;
 END Give_Tunnel_Order;
/

Give_Association Renvoie en une seule chaine de caractères la liste de tous les esclaves d'une alimentation
CREATE OR REPLACE FUNCTION Give_Association(PartType IN VARCHAR2,IDNumber IN VARCHAR2) RETURN VARCHAR2 IS
  Association VARCHAR2(50);
  Symbol VARCHAR2(3);
  CURSOR AssociationCursor IS
    SELECT DISTINCT Type,Logical_Name
    FROM Alim.pc_associated,Alim.Located
    WHERE pc_associated.Part_Type2=located.Part_Type1(+)
    AND pc_associated.Id_Number2=located.ID_Number1(+)
    AND pc_associated.Part_Type1=PartType AND pc_associated.Id_Number1=IDNumber;

BEGIN
   Association := '';
   FOR AssociationRecord IN AssociationCursor LOOP
      Symbol := '+ ';
      IF substr(AssociationRecord.type,1,1)='P' THEN
         Symbol := '// ';
      END IF;
      Association := Association || symbol || AssociationRecord.Logical_Name || chr(13) || chr(10);
   END LOOP;
   RETURN Association;
END Give_Association;
/

Give_Division Renvoie 0 s'il y a division par zèro
CREATE OR REPLACE FUNCTION Give_Division(Numerator IN NUMBER,Denominator IN NUMBER) RETURN NUMBER IS
BEGIN
   IF Denominator IS NULL OR Denominator=0 THEN
      RETURN 0;
   ELSE
      RETURN Numerator/Denominator;
   END IF;
END Give_Division;

Give_Magnet_Beam_Name Renvoie la liste des faisceaux dont fait partie une alimentation
CREATE OR REPLACE FUNCTION Give_Magnet_Beam_Name(PartType IN VARCHAR2,IDNumber IN VARCHAR2) RETURN VARCHAR2 IS
  MagnetBeamName VARCHAR2(255);
  CURSOR MagnetCursor IS
    SELECT DISTINCT Magnet_Name || '/' || Alim.Give_Name('BEAM',id_Beam) AS MagnetBeamName
    FROM Alim.Beam_Magnet
    WHERE Part_Type=PartType AND Id_Number=IDNumber;
BEGIN
   MagnetBeamName := '';
   FOR MagnetRecord IN MagnetCursor LOOP
      MagnetBeamName := MagnetBeamName || ',' || MagnetRecord.MagnetBeamName;
   END LOOP;
   RETURN substr(MagnetBeamName,2);
END Give_Magnet_Beam_Name;

Give_Logical_Name Donne le nom opérationnel d'une alimentation
CREATE OR REPLACE FUNCTION Give_Logical_Name(PartType IN VARCHAR2,IDNumber IN VARCHAR2) RETURN VARCHAR2 IS
  LogicalName VARCHAR2(255);
BEGIN
    SELECT DISTINCT Logical_Name INTO LogicalName
    FROM Alim.Located
    WHERE Part_Type1=PartType AND Id_Number1=IDNumber
    AND Date_of_Unloc IS NULL;

   RETURN LogicalName;
END Give_Logical_Name;