<?xml version="1.0" encoding="UTF-8"?>

<!-- 
    File Schematron per Requisiti e Raccomandazioni Scheda Censimento PELL
    Versione: 2.0
    Ultima modifica: 08-03-2022 
    
-->

<sch:schema xmlns="" xmlns:sch="http://purl.oclc.org/dsdl/schematron"
  xmlns:gml="http://www.opengis.net/gml/3.2" xmlns:xlink="http://www.w3.org/1999/xlink"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" queryBinding="xslt2"
  xmlns:fn="http://www.w3.org/2005/xpath-functions"
  xmlns:sqf="http://www.schematron-quickfix.com/validator/process">
  <!-- title>Requisiti per la Scheda Censimento PELL Illuminazione Pubblica</title-->
  <sch:ns prefix="gml" uri="http://www.opengis.net/gml/3.2"/>
  <sch:ns prefix="xsi" uri="http://www.w3.org/2001/XMLSchema-instance"/>
  <sch:ns prefix="xlink" uri="http://www.w3.org/1999/xlink"/>

  <sch:phase id="PELL">
    <sch:active pattern="XML-CensusTechSheet"/>
  </sch:phase>


  <sch:pattern abstract="false" id="XML-CensusTechSheet">

    <sch:rule context="/CensusTechSheet">

      <sch:assert
        test="((count(//ElectricPanelGeneralData[OperatingStatus = '03']) = 0) and (number(PLSystemGeneralData/NumberOfConnectedLightSpots) = sum(//ElectricPanelGeneralData/NumberOfConnectedLightSpots))) or ((count(//ElectricPanelGeneralData[OperatingStatus = '03']) &gt; 0) and (number(PLSystemGeneralData/NumberOfConnectedLightSpots) &gt;= sum(//ElectricPanelGeneralData[not(OperatingStatus = '03')]/NumberOfConnectedLightSpots)) and (number(PLSystemGeneralData/NumberOfConnectedLightSpots) &lt;= sum(//ElectricPanelGeneralData/NumberOfConnectedLightSpots)))"
        flag="fatal">[Req 13] - Se nel documento non sono presenti quadri elettrici "in disuso", il
        numero di punti luce totali (PLSystemGeneralData/NumberOfConnectedLightSpots) DEVE essere
        uguale al numero di punti luce afferenti ai singoli quadri elettrici descritti nel documento
        (somma dei valori degli elementi
        //ElectricPanel/ElectricPanelGeneralData/NumberOfConnectedLightSpots). Se nel documento sono
        presenti quadri elettrici "in disuso", il numero di punti luce totali
        (PLSystemGeneralData/NumberOfConnectedLightSpots) DEVE essere maggiore o uguale al numero di
        punti luce afferenti ai singoli quadri elettrici non "in disuso" descritti nel documento
        (somma dei valori degli elementi
        //ElectricPanel/ElectricPanelGeneralData/NumberOfConnectedLightSpots aventi il relativo
        elemento ElectricPanelGeneralData/OperatingStatus diverso da '03'.) e minore o uguale al
        numero di punti luce afferenti ai singoli quadri elettrici (somma dei valori degli elementi
        //ElectricPanel/ElectricPanelGeneralData/NumberOfConnectedLightSpots).</sch:assert>

      <sch:assert
        test="((count(//ElectricPanelGeneralData[OperatingStatus = '03']) = 0) and (number(PLSystemGeneralData/NumberOfOwnedLightSpots) = number(sum(//ElectricPanelGeneralData[not(OperatingStatus = '03')]/NumberOfOwnedLightSpots)))) or ((count(//ElectricPanelGeneralData[OperatingStatus = '03']) &gt; 0) and (number(PLSystemGeneralData/NumberOfOwnedLightSpots) &gt;= number(sum(//ElectricPanelGeneralData[not(OperatingStatus = '03')]/NumberOfOwnedLightSpots))) and (number(PLSystemGeneralData/NumberOfOwnedLightSpots) &lt;= number(sum(//ElectricPanelGeneralData/NumberOfOwnedLightSpots))))"
        flag="fatal">[Req 144] - Se nel documento non sono presenti quadri elettrici "in disuso", il
        numero di punti luce di proprietà (NumberOfOwnedLightSpots) DEVE essere uguale al numero
        totale di punti luce di proprietà afferenti a quadri elettrici del documento. Se nel
        documento sono presenti quadri elettrici "in disuso", il numero di punti luce di proprietà
        (NumberOfOwnedLightSpots) DEVE essere maggiore o uguale al numero totale di punti luce di
        proprietà afferenti a quadri elettrici non "in disuso" e minore o uguale al numero totale di
        punti luce di proprietà afferenti a quadri elettrici del documento.</sch:assert>

      <sch:assert
        test="((count(//ElectricPanelGeneralData[OperatingStatus = '03']) = count(//ElectricPanelGeneralData)) or (not(count(//HomogeneousArea/LightSpotDeviceRefs[@xsi:nil = 'true']) > 0)))"
        flag="fatal">[Req 141] - La Zona Omogenea DEVE avere i riferimenti a Punti Luce Apparecchio,
        a meno che nel documento non siano descritti solo quadri elettrici "in disuso". </sch:assert>


      <sch:assert
        test="((count(//ElectricPanelGeneralData[OperatingStatus = '03']) = 0) and number(PLSystemGeneralData/NumberOfConnectedLightSpots) = count(//LightSpot)) or ((count(//ElectricPanelGeneralData[OperatingStatus = '03']) &gt; 0) and (number(PLSystemGeneralData/NumberOfConnectedLightSpots) &gt;= count(//LightSpot[ElectricPanelID = //ElectricPanelID[ancestor::ElectricPanel[ElectricPanelGeneralData[not(OperatingStatus = '03')]]]])))"
        flag="fatal">[Req 90] - Se nel documento non sono presenti quadri elettrici "in disuso", il
        numero di punti luce totali (NumberOfConnectedLightSpots) DEVE essere uguale al numero di
        punti luce descritti nel documento (numero di blocchi LightSpot). Se nel documento sono
        presenti quadri elettrici "in disuso", il numero di punti luce totali
        (PLSystemGeneralData/NumberOfConnectedLightSpots) DEVE essere maggiore o uguale al numero di
        punti luce descritti nel documento e afferenti a quadri elettrici non "in disuso" (numero di
        blocchi //LightSpot afferenti a quadri non "in disuso").</sch:assert>

      <sch:assert
        test="(count(//LightSpotDevice/LightSpotDeviceID) = count(distinct-values(//LightSpotDevice/normalize-space(LightSpotDeviceID))))"
        flag="fatal">[Req 87] - L'identificativo dell'apparecchio (LightSpotDeviceID) DEVE essere
        univoco all'interno del documento XML.</sch:assert>

      <sch:assert
        test="(count(//POD/PODCode) = count(distinct-values(//POD/normalize-space(PODCode))))"
        flag="fatal">[Req 88] - Il codice POD (POD/PODCode) DEVE essere univoco all'interno del
        documento XML.</sch:assert>

      <sch:assert
        test="(count(//ElectricPanel/ElectricPanelID) = count(distinct-values(//ElectricPanel/normalize-space(ElectricPanelID))))"
        flag="fatal">[Req 27] - L'identificativo del quadro (//ElectricPanel/ElectricPanelID) DEVE
        essere univoco all'interno del documento XML.</sch:assert>

      <sch:assert
        test="(count(//HomogeneousArea/HomogeneousAreaID) = count(distinct-values(//HomogeneousArea/normalize-space(HomogeneousAreaID))))"
        flag="fatal">[Req 91] - L'identificativo della zona omogenea (HomogeneousAreaID) DEVE essere
        univoco all'interno del documento XML.</sch:assert>

      <sch:assert
        test="(count(//LightSource/LightSourceID) = count(distinct-values(//LightSource/normalize-space(LightSourceID))))"
        flag="fatal">[Req 93] - L'id sorgente luminosa (LightSourceID) DEVE essere univoco
        all'interno del documento XML.</sch:assert>

      <sch:assert
        test="count(distinct-values(//POD/PODConsumptionData/normalize-space(PublicTenderID))) = 1"
        flag="fatal">[Req 138] Il CIG DEVE essere lo stesso per tutti i POD descritti nel documento </sch:assert>

      <sch:assert
        test="(count(//ElectricPanelGeneralData/OperatingStatus = '03') &gt; 0) or (count(//LightSpotDevice) = count(distinct-values(//LightSpotDeviceID[ancestor::LightSpotDeviceRefs])))"
        flag="fatal">[Req 145] - Se nel documento non ci sono Quadri elettrici in disuso, ogni
        apparecchio DEVE essere collegato ad una Zona Omogenea.</sch:assert>

      <sch:assert
        test="(count(//ElectricPanelGeneralData[OperatingStatus = '03']) = count(//ElectricPanelGeneralData)) or (not(number(PLSystemGeneralData/PercentageOfConnectedLightSpots) = 0))"
        flag="fatal">[Req 147] - La Percentuale punti luce rispetto al totale comunale DEVE essere
        maggiore di zero, a meno che nel documento non siano descritti solo quadri elettrici "in
        disuso". </sch:assert>

      <sch:assert
        test="not(count(//ElectricPanelGeneralData[OperatingStatus = '03']) = count(//ElectricPanelGeneralData)) or (number(PLSystemGeneralData/PercentageOfConnectedLightSpots) = 0)"
        flag="warning">[Racc 120] - Se nel documento sono descritti solo quadri elettrici "in
        disuso", la Percentuale punti luce rispetto al totale comunale DOVREBBE essere zero. </sch:assert>

    </sch:rule>

    <sch:rule context="/CensusTechSheet/PLSystemGeneralData">

      <sch:assert
        test="(count(City) &lt;= 1) or ((count(City[@ln]) = count(City)) and (count(City/@ln) = count(distinct-values(City/@ln))))"
        flag="fatal">[Req 9] - Se il nome comune (City) occorre più di una volta, ogni occorrenza
        DEVE avere l'attributo @ln valorizzato e i valori delle varie occorrenze di @ln DEVONO
        essere distinti.</sch:assert>

      <sch:assert test="not(Surface) or (Surface[@uom = 'km2'])" flag="warning">[Racc 3] -
        L'attributo XML @uom (unità di misura) dell'elemento Surface DOVREBBE essere presente e
        valorizzato con il valore prefissato "km2".</sch:assert>

      <sch:assert test="number(NumberOfConnectedLightSpots) &gt;= number(NumberOfOwnedLightSpots)"
        flag="fatal">[Req 15] - Il numero di punti luce di proprietà (NumberOfOwnedLightSpots) DEVE
        essere minore o uguale al numero di punti luce totali descritti nel singolo documento XML
        (NumberOfConnectedLightSpots).</sch:assert>

      <sch:assert
        test="number(NumberOfOwnedLightSpots) &lt;= sum(//ElectricPanelGeneralData/NumberOfConnectedLightSpots)"
        flag="fatal">[Req 127] - Il numero di punti luce di proprietà (NumberOfOwnedLightSpots) DEVE
        essere minore o uguale alla somma dei punti luce indicati nei singoli quadri
        elettrici.</sch:assert>

      <sch:assert
        test="(NumberOfTotalLightSpots[@xsi:nil = 'true']) or (number(NumberOfTotalLightSpots) &gt;= number(NumberOfConnectedLightSpots))"
        flag="fatal">[Req 137] - Se valorizzato, il numero totale punti luce comunali
        (NumberOfTotalLightSpots) DEVE essere maggiore o uguale al numero di punti luce associati
        all'anagrafica ed inseriti nella scheda.</sch:assert>

    </sch:rule>

    <sch:rule context="//PODGeneralData">
      <sch:let name="podCode" value="preceding-sibling::PODCode"/>

      <sch:assert
        test="
          ((NumberOfElectricPanelsToBeChanged[@xsi:nil = 'true']) and (NumberOfElectricPanelsToBeReconditioned[@xsi:nil = 'true'])) or (number(NumberOfElectricPanels) &gt;= (number(NumberOfElectricPanelsToBeChanged) + number(NumberOfElectricPanelsToBeReconditioned))) or
          ((number(NumberOfElectricPanels) &gt;= number(NumberOfElectricPanelsToBeChanged)) and (NumberOfElectricPanelsToBeReconditioned[@xsi:nil = 'true'])) or ((number(NumberOfElectricPanels) &gt;= number(NumberOfElectricPanelsToBeReconditioned)) and (NumberOfElectricPanelsToBeChanged[@xsi:nil = 'true']))"
        flag="fatal">[Req 18] - Se il numero quadri elettrici da sostituire
        (NumberOfElectricPanelsToBeChanged) e/o il numero quadri elettrici da ricondizionare
        (NumberOfElectricPanelsToBeReconditioned) afferenti un POD sono indicati, la loro somma DEVE
        essere minore o uguale al numero di quadri elettrici (NumberOfElectricPanels) del
        POD.</sch:assert>

      <sch:assert test="(NumberOfElectricPanels) = count(//ElectricPanel[PODCode = $podCode])"
        flag="fatal">[Req 19] - Il numero di quadri elettrici afferenti il POD
        (NumberOfElectricPanels) DEVE essere uguale al numero di quadri elettrici (numero di blocchi
        //ElectricPanel) afferenti quello stesso POD descritti nel documento XML.</sch:assert>

      <sch:assert
        test="(NumberOfElectricPanelsToBeChanged[@xsi:nil = 'true']) or ((NumberOfElectricPanelsToBeChanged) = count(//ElectricPanel[PODCode = $podCode]/ElectricPanelGeneralData[PreservationStatus = '04']))"
        flag="warning">[Racc 4] - Se non nullo, il numero quadri elettrici da sostituire
        (NumberOfElectricPanelsToBeChanged) afferenti il POD DOVREBBE essere uguale al numero di
        quadri elettrici collegati a quel POD aventi stato di conservazione = "da sostituire"
        (ElectricPanel/ElectricPanelGeneralData/PreservationStatus = "04").</sch:assert>

      <sch:assert
        test="(NumberOfElectricPanelsToBeReconditioned[@xsi:nil = 'true']) or ((NumberOfElectricPanelsToBeReconditioned) = count(//ElectricPanel[PODCode = $podCode]/ElectricPanelGeneralData[PreservationStatus = '02' or PreservationStatus = '03']))"
        flag="warning">[Racc 5] - Se non nullo, il numero quadri elettrici da ricondizionare
        (NumberOfElectricPanelsToBeReconditioned) DOVREBBE essere uguale al numero di quadri
        elettrici collegati al POD e aventi stato di conservazione = "da mettere a norma" o "da
        manutenere" (numero di blocchi ElectricPanel aventi
        ElectricPanelGeneralData/PreservationStatus = "02" o = "03").</sch:assert>

    </sch:rule>

    <sch:rule context="//PODConsumptionData">

      <sch:assert
        test="not(InstalledPower) or (InstalledPower[@uom = 'kW']) or (InstalledPower[@xsi:nil = 'true'])"
        flag="warning">[Racc 6] - L'attributo XML @uom (unità di misura) dell'elemento
        InstalledPower DOVREBBE essere presente e valorizzato con il valore prefissato
        "kW".</sch:assert>

      <sch:assert
        test="not(PreviousYearAnnualConsumption) or (PreviousYearAnnualConsumption[@uom = 'kWh'])"
        flag="warning">[Racc 7] - L'attributo XML @uom (unità di misura) dell'elemento
        PreviousYearAnnualConsumption DOVREBBE essere presente e valorizzato con il valore
        prefissato "kWh".</sch:assert>

      <sch:assert
        test="not(ContractuallyCommittedPower) or (ContractuallyCommittedPower[@uom = 'kW'])"
        flag="warning">[Racc 8] - L'attributo XML @uom (unità di misura) dell'elemento
        ContractuallyCommittedPower DOVREBBE essere presente e valorizzato con il valore prefissato
        "kW".</sch:assert>

      <sch:assert
        test="not(CurrentYearAnnualConsumption) or (CurrentYearAnnualConsumption[@uom = 'kWh'])"
        flag="warning">[Racc 9] - L'attributo XML @uom (unità di misura) dell'elemento
        CurrentYearAnnualConsumption DOVREBBE essere presente e valorizzato con il valore prefissato
        "kWh".</sch:assert>

      <sch:assert
        test="not(PreviousYearElectricEnergyAnnualAmount) or (PreviousYearElectricEnergyAnnualAmount[@currency = 'EUR'])"
        flag="warning">[Racc 2] - L'elemento PreviousYearElectricEnergyAnnualAmount corrisponde ad
        un attributo del Data model indicante un importo, DOVREBBE quindi avere l'attributo XML
        @currency (valuta) valorizzato con il valore prefissato "EUR".</sch:assert>

      <sch:assert
        test="not(CurrentYearElectricEnergyAnnualAmount) or (CurrentYearElectricEnergyAnnualAmount[@currency = 'EUR'])"
        flag="warning">[Racc 2] - L'elemento CurrentYearElectricEnergyAnnualAmount corrisponde ad un
        attributo del Data model indicante un importo, DOVREBBE quindi avere l'attributo XML
        @currency (valuta) valorizzato con il valore prefissato "EUR".</sch:assert>

      <sch:assert test="not(PreRenewalConsumptions[@xsi:nil = 'true'])" flag="warning">[Racc 118] -
        Non sono stati forniti i consumi mensile del periodo precedente alla riqualificazione; i
        Certificati Bianchi (TEE) non potranno essere richiesti.</sch:assert>

      <sch:assert
        test="(PreRenewalConsumptions[@xsi:nil = 'true']) or (count(distinct-values(PreRenewalConsumptions/MonthlyConsumption/@yearMonth)) = 12)"
        flag="fatal">[Req 143] - I 12 mesi a cui fanno riferimento i consumi del periodo precedente
        alla riqualificazione DEVONO essere distinti.</sch:assert>

      <sch:assert test="not(NumberOfCorrespondingOperatingHours[@xsi:nil = 'true'])" flag="warning"
        >[Racc 119] - Il dato sulle ore equivalente di funzionamento non e' stato fornito; i
        Certificati Bianchi (TEE) non potranno essere richiesti.</sch:assert>
    </sch:rule>

    <sch:rule context="//ElectricPanel">
      <sch:let name="refPodCode" value="PODCode"/>
      <!-- NUOVE REGOLE PER LA GESTIONE DEL QUADRO IN DISUSO -->
      <sch:assert
        test="(ElectricPanelGeneralData/OperatingStatus = '03') or (count(//POD[PODCode = $refPodCode]) > 0)"
        flag="fatal">[Req 29] - Se il quadro non e' "in disuso", il codice POD indicato nel quadro
        elettrico (PODCode) DEVE essere uguale al codice di uno dei POD (//POD/PODCode) descritti
        nel documento XML.</sch:assert>
      <sch:assert
        test="(ElectricPanelGeneralData/OperatingStatus = '03') or (count(ElectricPanelTechnicalData) = 1)"
        flag="fatal">[Req 128] - Se il quadro non e' "in disuso", i dati tecnici del quadro
        (ElectricPanelGeneralData) DEVONO essere forniti.</sch:assert>

      <sch:assert
        test="(ElectricPanelGeneralData/OperatingStatus = '03') or (count(ElectricPanelOperatingData) = 1)"
        flag="fatal">[Req 129] - Se il quadro non e' "in disuso", i dati funzionamento e gestione
        del quadro (ElectricPanelOperatingData) DEVONO essere forniti.</sch:assert>
      <sch:assert
        test="(ElectricPanelGeneralData/OperatingStatus = '03') or (count(ElectricPanelMaintenance) = 1)"
        flag="fatal">[Req 130] - Se il quadro non e' "in disuso", i dati di manutenzione del quadro
        (ElectricPanelMaintenance) DEVONO essere forniti.</sch:assert>

    </sch:rule>

    <sch:rule context="//ElectricPanel/ElectricPanelGeneralData">
      <sch:let name="electricPanID" value="preceding-sibling::ElectricPanelID"/>
      <sch:let name="hAreaList"
        value="distinct-values(//LightSpot[ElectricPanelID = $electricPanID]/HomogeneousAreaID)"/>

      <sch:assert
        test="not(ElectricPanelInstalledPower) or (ElectricPanelInstalledPower[@uom = 'kW']) or (ElectricPanelInstalledPower[@xsi:nil = 'true'])"
        flag="warning">[Racc 11] - L'attributo XML @uom (unità di misura) dell'elemento
        ElectricPanelInstalledPower DOVREBBE essere presente e valorizzato con il valore prefissato
        "kW".</sch:assert>

      <sch:assert
        test="number(NumberOfConnectedLightSpots) = (number(NumberOfOwnedLightSpots) + number(NumberOfNotOwnedLightSpots))"
        flag="fatal">[Req 32] - Il numero totale di punti luce (NumberOfConnectedLightSpots) DEVE
        essere uguale alla somma tra il numero di punti luce di proprietà e non di proprietà
        (NumberOfOwnedLightSpots e NumberOfNotOwnedLightSpots) associati allo stesso
        quadro.</sch:assert>

      <sch:assert
        test="(OperatingStatus = '03') or ((number(NumberOfConnectedLightSpots) = count(//LightSpot[ElectricPanelID = $electricPanID])))"
        flag="fatal">[Req 33] - Se il quadro elettrico non e' "in disuso", il numero totale di punti
        luce (NumberOfConnectedLightSpots) DEVE essere uguale numero di punti luce associati al
        quadro elettrico presenti nel documento (numero di blocchi LightSpot aventi ElectricPanelID
        uguale all'identificativo del quadro che si sta considerando).</sch:assert>

      <!-- NUOVE REGOLE PER LA GESTIONE DEL QUADRO IN DISUSO -->
      <sch:assert
        test="(OperatingStatus = '03') or (not(ElectricPanelInstalledPower[@xsi:nil = 'true']))"
        flag="fatal">[Req 131] - Se il quadro non e' "in disuso", la potenza installata
        (ElectricPanelInstalledPower) DEVE essere fornita.</sch:assert>
      <sch:assert test="(OperatingStatus = '03') or (number(NumberOfConnectedLightSpots) > 0)"
        flag="fatal">[Req 132] - Se il quadro non e' "in disuso", il numero totale di punti luce
        (NumberOfConnectedLightSpots) DEVE essere maggiore di zero.</sch:assert>
      <sch:assert
        test="(OperatingStatus = '03') or (not(ExogenousElectricalLoads = '91') and not(ExogenousElectricalLoads = '93') and not(ExogenousElectricalLoads = '94'))"
        flag="fatal">[Req 133] - Se il quadro non e' "in disuso", l'informazione relativa alla
        presenza dei carichi esogeni elettrici (ExogenousElectricalLoads) DEVE essere
        fornita.</sch:assert>
      <sch:assert
        test="(OperatingStatus = '03') or (not(SupportRedevelopingNeeds = '91') and not(SupportRedevelopingNeeds = '93') and not(SupportRedevelopingNeeds = '94'))"
        flag="fatal">[Req 134] - Se il quadro non e' "in disuso", l'informazione relativa ai
        sostegni da riqualificare (SupportRedevelopingNeeds) DEVE essere fornita.</sch:assert>
      <sch:assert test="(OperatingStatus = '03') or (number(NumberOfSupports) > 0)" flag="fatal"
        >[Req 132] - Se il quadro non e' "in disuso", il numero numero sostegni (NumberOfSupports)
        DEVE essere maggiore di zero.</sch:assert>


    </sch:rule>

    <sch:rule context="//ElectricPanel/ElectricPanelTechnicalData">

      <sch:assert
        test="(Ipei2013 = '91') or (Ipei2013 = '93') or (Ipei2013 = '94') or (Ipei2018 = '91') or (Ipei2018 = '93') or (Ipei2018 = '94')"
        flag="fatal">[Req 94] - Se è stato valorizzato l'indice IPEI 2013 (Ipei2013), l'indice IPEI
        2018 (Ipei2018) DEVE assumere uno dei valori di indeterminatezza.</sch:assert>

      <sch:assert test="not(NominalVoltage) or (NominalVoltage[@uom = 'V'])" flag="warning">[Racc
        12] - L'attributo XML @uom (unità di misura) dell'elemento NominalVoltage DOVREBBE essere
        presente e valorizzato con il valore prefissato "V".</sch:assert>

      <sch:assert
        test="(((TransformerFlag = 'false') or (TransformerFlag[@xsi:nil = 'true']) or not(TransformerFlag)) and (not(TransformerPower) or (TransformerPower[@xsi:nil = 'true']))) or ((TransformerFlag = 'true') and (TransformerPower/node()))"
        flag="fatal">[Req 98] - Se è stato dichiarato che è presente un trasformatore di tensione in
        cabina elettrica, la potenza del trasformatore (TransformerPower) DEVE essere
        presente.</sch:assert>

      <sch:assert
        test="not(TransformerPower) or (TransformerPower[@uom = 'kV*A']) or (TransformerPower[@xsi:nil = 'true'])"
        flag="warning">[Racc 14] - L'attributo XML @uom (unità di misura) dell'elemento
        TransformerPower DOVREBBE essere presente e valorizzato con il valore prefissato
        "kV*A".</sch:assert>

    </sch:rule>

    <sch:rule context="//ElectricPanel/ElectricPanelOperatingData">

      <sch:assert
        test="((PowerOnPartializationFlag = 'true') and (number(NumberOfOperatingHours) > number(NumberOfPartialOperatingHours))) or ((PowerOnPartializationFlag = 'false') and (NumberOfPartialOperatingHours[@xsi:nil = 'true']))"
        flag="fatal">[Req 45] - Se è stato indicato che l'accensione è parzializzata
        (PowerOnPartializationFlag = 'true'), la durata di accensione parzializzata
        (NumberOfPartialOperatingHours) DEVE essere indicata e il valore DEVE essere inferiore al
        numero di ore di accensione dell'impianto (NumberOfOperatingHours). Nel caso di accensione
        non parzializzata (PowerOnPartializationFlag = 'false'), l'elemento
        NumberOfPartialOperatingHours DEVE essere valorizzato con il valore di
        indeterminatezza.</sch:assert>

      <sch:assert
        test="not(PowerOnPartializationFlag = 'true') or (LuminousFluxReducingFlag[@xsi:nil = 'true'])"
        flag="fatal">[Req 46] - In caso di accensione parzializzata (PowerOnPartializationFlag =
        'true'), la riduzione del flusso luminoso (LuminousFluxReducingFlag) DEVE avere valore
        nullo.</sch:assert>

      <sch:assert
        test="((LuminousFluxReducingFlag = 'true') and (not(NumberOfReducedFluxOperatingHours[@xsi:nil = 'true'])) and (number(NumberOfOperatingHours) > number(NumberOfReducedFluxOperatingHours))) or (not(LuminousFluxReducingFlag = 'true') and (NumberOfReducedFluxOperatingHours[@xsi:nil = 'true']))"
        flag="fatal">[Req 48] - In caso di attuazione di strategie di riduzione del flusso luminoso
        (LuminousFluxReducingFlag = 'true'), la durata di riduzione del flusso luminoso
        (NumberOfReducedFluxOperatingHours) DEVE essere valorizzata e il valore DEVE essere
        inferiore al numero di ore di accensione dell'impianto (NumberOfOperatingHours); altrimenti
        DEVE assumere il valore nullo.</sch:assert>

      <sch:assert
        test="((LuminousFluxReducingFlag = 'true') and not(ReductionRate[@xsi:nil = 'true'])) or (not(LuminousFluxReducingFlag = 'true') and (ReductionRate[@xsi:nil = 'true']))"
        flag="fatal">[Req 50] - In caso di utilizzo di strategie di riduzione del flusso luminoso
        (LuminousFluxReducingFlag = 'true'), il valore medio di riduzione del flusso luminoso
        (ReductionRate) DEVE essere valorizzato; altrimenti DEVE assumere il valore
        nullo.</sch:assert>

      <sch:assert
        test="((not(MeterID) or (MeterID[@xsi:nil = 'true'])) and (not(MeterClass) or (MeterClass = '91') or (MeterClass = '93') or (MeterClass = '94'))) or ((MeterID/text()) and (MeterClass) and not((MeterClass = '91') or (MeterClass = '93') or (MeterClass = '94')))"
        flag="fatal">[Req 51] - Se presenti, le informazioni sul meter DEVONO essere complete:
        occorre indicare sia l'identificativo (MeterID) che la classe (MeterClass).</sch:assert>

      <sch:assert
        test="((PowerOnPartializationFlag = 'false') and (PowerReductionRate[@xsi:nil = 'true'])) or ((PowerOnPartializationFlag = 'true') and not(PowerReductionRate[@xsi:nil = 'true']))"
        flag="fatal">[Req 52] - In caso di parzializzazione accensione tutta notte - mezza notte
        (PowerOnPartializationFlag = 'true'), la percentuale di riduzione della potenza
        (PowerReductionRate) DEVE essere fornita; altrimenti DEVE assumere il valore
        nullo.</sch:assert>

      <sch:assert
        test="((LuminousFluxReducingFlag = 'true') and (not(PowerAverageReductionRate[@xsi:nil = 'true']))) or (not(LuminousFluxReducingFlag = 'true') and (PowerAverageReductionRate[@xsi:nil = 'true']))"
        flag="fatal">[Req 53] - In caso di utilizzo di strategie di riduzione del flusso luminoso,
        la percentuale di riduzione media della potenza (PowerAverageReductionRate) DEVE essere
        fornita, altrimenti DEVE assumere il valore nullo.</sch:assert>

    </sch:rule>

    <sch:rule context="//ElectricPanel/ElectricPanelMaintenance">
      <sch:assert
        test="not(PreviousYearOrdinaryMaintenanceAmount) or (PreviousYearOrdinaryMaintenanceAmount[@currency = 'EUR'])"
        flag="warning">[Racc 2] - L'elemento PreviousYearOrdinaryMaintenanceAmount corrisponde ad un
        attributo del Data model indicante un importo, DOVREBBE quindi avere l'attributo XML
        @currency (valuta) valorizzato con il valore prefissato "EUR".</sch:assert>

      <sch:assert
        test="not(PreviousYearOtherOrdinaryMaintenanceAmount) or (PreviousYearOtherOrdinaryMaintenanceAmount[@currency = 'EUR'])"
        flag="warning">[Racc 2] - L'elemento PreviousYearOtherOrdinaryMaintenanceAmount corrisponde
        ad un attributo del Data model indicante un importo, DOVREBBE quindi avere l'attributo XML
        @currency (valuta) valorizzato con il valore prefissato "EUR".</sch:assert>

      <sch:assert
        test="not(PreviousYearExtraordinaryMaintenanceAmount) or (PreviousYearExtraordinaryMaintenanceAmount[@currency = 'EUR'])"
        flag="warning">[Racc 2] - L'elemento PreviousYearExtraordinaryMaintenanceAmount corrisponde
        ad un attributo del Data model indicante un importo, DOVREBBE quindi avere l'attributo XML
        @currency (valuta) valorizzato con il valore prefissato "EUR".</sch:assert>

      <sch:assert
        test="not(CurrentYearOrdinaryMaintenanceAmount) or (CurrentYearOrdinaryMaintenanceAmount[@currency = 'EUR'])"
        flag="warning">[Racc 2] - L'elemento CurrentYearOrdinaryMaintenanceAmount corrisponde ad un
        attributo del Data model indicante un importo, DOVREBBE quindi avere l'attributo XML
        @currency (valuta) valorizzato con il valore prefissato "EUR".</sch:assert>

      <sch:assert
        test="not(CurrentYearOtherOrdinaryMaintenanceAmount) or (CurrentYearOtherOrdinaryMaintenanceAmount[@currency = 'EUR'])"
        flag="warning">[Racc 2] - L'elemento CurrentYearOtherOrdinaryMaintenanceAmount corrisponde
        ad un attributo del Data model indicante un importo, DOVREBBE quindi avere l'attributo XML
        @currency (valuta) valorizzato con il valore prefissato "EUR".</sch:assert>

      <sch:assert
        test="not(CurrentYearExtraordinaryMaintenanceAmount) or (CurrentYearExtraordinaryMaintenanceAmount[@currency = 'EUR'])"
        flag="warning">[Racc 2] - L'elemento CurrentYearExtraordinaryMaintenanceAmount corrisponde
        ad un attributo del Data model indicante un importo, DOVREBBE quindi avere l'attributo XML
        @currency (valuta) valorizzato con il valore prefissato "EUR".</sch:assert>

    </sch:rule>


    <sch:rule context="//LightSpot">
      <sch:let name="electricPanID" value="ElectricPanelID"/>

      <sch:assert test="(//ElectricPanel[ElectricPanelID = $electricPanID])" flag="fatal">[Req 54] -
        L'identificativo del quadro elettrico indicato nel punto luce (ElectricPanelID) DEVE essere
        uguale all'identificativo di uno dei quadri elettrici descritti nel documento
        (ElectricPanel/ElectricPanelID).</sch:assert>
    </sch:rule>

    <sch:rule context="//LightSpot/LightSpotDevice">
      <sch:let name="deviceID" value="LightSpotDeviceID"/>
      <sch:let name="epID" value="preceding-sibling::ElectricPanelID"/>

      <sch:assert
        test="(count(//ElectricPanel[ElectricPanelID = $epID][ElectricPanelGeneralData/OperatingStatus = '03']) &gt; 0) or (count(//LightSpotDeviceRefs/LightSpotDeviceID[. = $deviceID]) = 1)"
        flag="fatal">[Req 146] - Se l'apparecchio afferisce ad un Quadro Elettrico NON in disuso,
        DEVE essere collegato ad una e una sola Zona Omogenea.</sch:assert>

      <sch:assert
        test="(count(//LightSpot/LightSource[LightSpotDeviceID = $deviceID]) = NumberOfLamps)"
        flag="fatal">[Req 85] - Il numero di lampade o moduli per singolo apparecchio
        (NumberOfLamps) DEVE essere uguale al numero di sorgenti luminose (blocchi LightSource)
        associate all'apparecchio.</sch:assert>
      <sch:assert test="not(TerminalPower) or (TerminalPower[@uom = 'W'])" flag="warning">[Racc 19]
        - L'attributo XML @uom (unità di misura) dell'elemento TerminalPower DOVREBBE essere
        presente e valorizzato con il valore prefissato "W".</sch:assert>

      <sch:assert test="(Owner = '01') or (Owner = '02')" flag="warning">[Racc 20] - La proprietà
        del punto luce (Owner) DOVREBBE essere sempre indicata (si sconsiglia l'uso dei valori di
        indeterminatezza).</sch:assert>

      <sch:assert
        test="not(UpwardEmission) or (UpwardEmission[@uom] and not(UpwardEmission/@uom = '')) or (UpwardEmission[@xsi:nil = 'true'])"
        flag="fatal">[Req 97] - Se l'elemento UpwardEmission è presente, il suo attributo XML @uom
        (unità di misura) DEVE essere presente e valorizzato.</sch:assert>

      <sch:assert test="not(Flux) or (Flux[@uom = 'lm']) or (Flux[@xsi:nil = 'true'])"
        flag="warning">[Racc 21] - L'attributo XML @uom (unità di misura) dell'elemento Flux
        DOVREBBE essere presente e valorizzato con il valore prefissato "lm".</sch:assert>

      <sch:assert
        test="(Ipea2013 = '91') or (Ipea2013 = '93') or (Ipea2013 = '94') or (Ipea2018 = '91') or (Ipea2018 = '93') or (Ipea2018 = '94')"
        flag="fatal">[Req 95] - Se è stato valorizzato l'indice IPEA 2013 (Ipea2013), l'indice IPEA
        2018 (Ipea2018) DEVE assumere uno dei valori di indeterminatezza.</sch:assert>

    </sch:rule>

    <sch:rule context="//LightSpot/LightSpotEquipment">
      <sch:let name="pointID" value="gml:Point/@gml:id"/>
      <sch:assert test="(gml:Point/@gml:id)" flag="fatal">[Req 118] - L'identificativo geografico
        del punto luce DEVE essere fornito.</sch:assert>

      <sch:assert test="not(Height) or (Height[@uom = 'm'])" flag="warning">[Racc 15] - L'attributo
        XML @uom (unità di misura) dell'elemento Height DOVREBBE essere presente e valorizzato con
        il valore prefissato "m".</sch:assert>

      <sch:assert test="not(Incline) or (Incline[@uom = '°']) or (Incline[@xsi:nil = 'true'])"
        flag="warning">[Racc 16] - L'attributo XML @uom (unità di misura) dell'elemento Incline
        DOVREBBE essere presente e valorizzato con il valore prefissato "°".</sch:assert>

      <sch:assert test="not(Distance) or (Distance[@uom = 'm']) or (Distance[@xsi:nil = 'true'])"
        flag="warning">[Racc 17] - L'attributo XML @uom (unità di misura) dell'elemento Distance
        DOVREBBE essere presente e valorizzato con il valore prefissato "m".</sch:assert>

      <sch:assert test="not(Length) or (Length[@uom = 'm']) or (Length[@xsi:nil = 'true'])"
        flag="warning">[Racc 18] - L'attributo XML @uom (unità di misura) dell'elemento Length
        DOVREBBE essere presente e valorizzato con il valore prefissato "m".</sch:assert>

      <sch:assert
        test="((Distance) and ((starts-with(EquipmentType, '01')) or (starts-with(EquipmentType, '03')))) or not(Distance) or (Distance[@xsi:nil = 'true'])"
        flag="fatal">[Req 59] - Se la tipologia installazione (EquipmentType) è diversa da "su palo"
        o "su braccio" o da una delle loro sottotipologie, la distanza del sostegno dall’inizio
        della carreggiata (Distance) NON DEVE essere presente o, se presente, DEVE assumere il
        valore nullo.</sch:assert>

      <sch:assert
        test="((Length) and ((starts-with(EquipmentType, '01')) or (starts-with(EquipmentType, '03')))) or not(Length) or (Length[@xsi:nil = 'true'])"
        flag="fatal">[Req 61] - Se la tipologia installazione (EquipmentType) è diversa da "su palo"
        o "su braccio" o da una delle loro sottotipologie, la lunghezza braccio (Length) NON DEVE
        essere presente o, se presente, DEVE assumere il valore nullo.</sch:assert>

    </sch:rule>

    <sch:rule context="//LightSpot/LightSource">
      <sch:let name="deviceID" value="LightSpotDeviceID"/>

      <sch:assert test="(preceding-sibling::LightSpotDevice[LightSpotDeviceID = $deviceID])"
        flag="fatal">[Req 96] - L'identificativo dell'apparecchio indicato nella sorgente luminosa
        (LightSpotDeviceID) DEVE essere uguale all'identificativo di uno degli apparecchi
        appartenenti al punto luce a cui è associata la sorgente luminosa.</sch:assert>

      <sch:assert test="not(NominalPower) or (NominalPower[@uom = 'W'])" flag="warning">[Racc 22] -
        L'attributo XML @uom (unità di misura) dell'elemento NominalPower DOVREBBE essere presente e
        valorizzato con il valore prefissato "W".</sch:assert>

      <sch:assert
        test="not(NominalLuminousFlux) or (NominalLuminousFlux[@uom = 'lm']) or (NominalLuminousFlux[@xsi:nil = 'true'])"
        flag="warning">[Racc 23] - L'attributo XML @uom (unità di misura) dell'elemento
        NominalLuminousFlux DOVREBBE essere presente e valorizzato con il valore prefissato
        "lm".</sch:assert>

      <sch:assert test="not(CCT) or (CCT[@uom = 'k']) or (CCT[@xsi:nil = 'true'])" flag="warning"
        >[Racc 24] - L'attributo XML @uom (unità di misura) dell'elemento CCT DOVREBBE essere
        presente e valorizzato con il valore prefissato "k".</sch:assert>

    </sch:rule>


    <sch:rule context="//LightSpotDeviceID[ancestor::LightSpotDeviceRefs]">
      <sch:let name="devID" value="."/>
      <sch:assert test="(count(//LightSpotDeviceID[ancestor::LightSpotDevice][. = $devID]) = 1)"
        flag="fatal">[Req 119] - Ogni apparecchio della zona omogenea DEVE essere descritto nel
        documento.</sch:assert>
    </sch:rule>

    <sch:rule context="//HomogeneousArea">
      <sch:let name="homogArea" value="HomogeneousAreaID"/>

      <sch:assert
        test="(count(LightSpotDeviceRefs/LightSpotDeviceID) = count(distinct-values(LightSpotDeviceRefs/LightSpotDeviceID)))"
        flag="fatal">[Req 142] - Gli identificativi apparecchio inidicati della zona omogenea DEVONO
        essere diversi.</sch:assert>

      <sch:assert
        test="not(GridLength) or (GridLength[@uom = 'm']) or (GridLength[@xsi:nil = 'true'])"
        flag="warning">[Racc 25] - L'attributo XML @uom (unità di misura) dell'elemento GridLength
        DOVREBBE essere presente e valorizzato con il valore prefissato "m".</sch:assert>

      <sch:assert test="not(GridWidth) or (GridWidth[@uom = 'm']) or (GridWidth[@xsi:nil = 'true'])"
        flag="warning">[Racc 26] - L'attributo XML @uom (unità di misura) dell'elemento GridWidth
        DOVREBBE essere presente e valorizzato con il valore prefissato "m".</sch:assert>

      <sch:assert
        test="((not(GridLength[@xsi:nil = 'true']) and not(GridWidth[@xsi:nil = 'true'])) or not(AreaSurface[@xsi:nil = 'true']))"
        flag="fatal">[Req 140] - O la superficie del reticolo di calcolo (AreaSurface) o lunghezza e
        larghezza del reticolo (GridLength e GridWidth) DEVONO essere fornite.</sch:assert>

      <sch:assert
        test="not(AreaSurface) or (AreaSurface[@uom = 'm2']) or (AreaSurface[@xsi:nil = 'true'])"
        flag="warning">[Racc 27] - L'attributo XML @uom (unità di misura) dell'elemento AreaSurface
        DOVREBBE essere presente e valorizzato con il valore prefissato "m2".</sch:assert>

      <sch:assert
        test="not(FootpathWidth) or (FootpathWidth[@uom = 'm']) or (FootpathWidth[@xsi:nil = 'true'])"
        flag="warning">[Racc 29] - L'attributo XML @uom (unità di misura) dell'elemento
        FootpathWidth DOVREBBE essere presente e valorizzato con il valore prefissato
        "m".</sch:assert>

      <sch:assert test="not(DistanceBetweenLightSpots) or (DistanceBetweenLightSpots[@uom = 'm'])"
        flag="warning">[Racc 30] - L'attributo XML @uom (unità di misura) dell'elemento
        DistanceBetweenLightSpots DOVREBBE essere presente e valorizzato con il valore prefissato
        "m".</sch:assert>

      <sch:assert
        test="not(OtherFootpathWidth) or (OtherFootpathWidth[@xsi:nil = 'true']) or (OtherFootpathWidth[@uom = 'm'])"
        flag="warning">[Racc 31] - L'attributo XML @uom (unità di misura) dell'elemento
        OtherFootpathWidth DOVREBBE essere presente e valorizzato con il valore prefissato
        "m".</sch:assert>

      <sch:assert
        test="(not(AreaTypology = '01') and ((RoadwayType = '91') or (RoadwayType = '93') or (RoadwayType = '94'))) or ((AreaTypology = '01') and (not(RoadwayType = '91') and not(RoadwayType = '93') and not(RoadwayType = '94')))"
        flag="fatal">[Req 70] - Se la tipologia di area illuminata (AreaTypology) è diversa da 'area
        di circolazione veicolare', il tipo carreggiata (RoadwayType) DEVE essere valorizzato con
        uno dei valori di indeterminatezza, altrimenti DEVE essere indicato uno dei tipi carreggiata
        previsti.</sch:assert>

      <sch:assert
        test="(AreaTypology = '01') or (not(NumberOfSecondRoadwayLanes)) or (NumberOfSecondRoadwayLanes[@xsi:nil = 'true'])"
        flag="fatal">[Req 73] - Se la tipologia di area illuminata (AreaTypology) è diversa da “area
        di circolazione veicolare”, il numero di corsie seconda carreggiata
        (NumberOfSecondRoadwayLanes) NON DEVE presente o, se presente, assumere il valore
        nullo.</sch:assert>

      <sch:assert
        test="((RoadwayType = '02') or (RoadwayType = '03')) or (not(NumberOfSecondRoadwayLanes)) or (NumberOfSecondRoadwayLanes[@xsi:nil = 'true'])"
        flag="warning">[Racc 28] - Il numero di corsie seconda carreggiata DOVREBBE essere
        valorizzato solo se il tipo di carreggiata (RoadwayType) è 'due carreggiate simmetriche' o
        'due carreggiate asimmetriche'.</sch:assert>

      <sch:assert
        test="(not(AreaTypology = '01') and ((RoadLightSpotAllocation = '91') or (RoadLightSpotAllocation = '93') or (RoadLightSpotAllocation = '94'))) or ((AreaTypology = '01') and (not(RoadLightSpotAllocation = '91') and not(RoadLightSpotAllocation = '93') and not(RoadLightSpotAllocation = '94')))"
        flag="fatal">[Req 75] - Se la tipologia di area illuminata (AreaTypology) è diversa da 'area
        di circolazione veicolare', l'elemento distribuzione stradale degli apparecchi
        (RoadLightSpotAllocation) DEVE essere valorizzato con il valore di indeterminatezza,
        altrimenti DEVE essere valorizzato con una delle opzioni previste.</sch:assert>

      <sch:assert
        test="(OtherAreaTypology = '91') or (OtherAreaTypology = '93') or (OtherAreaTypology = '94') or ((AreaTypology = '01') and ((OtherAreaTypology = '01') or (OtherAreaTypology = '02') or (OtherAreaTypology = '03') or (OtherAreaTypology = '04') or (OtherAreaTypology = '05') or (OtherAreaTypology = '06') or (OtherAreaTypology = '07'))) or ((AreaTypology = '02') and ((OtherAreaTypology = '02') or (OtherAreaTypology = '08')) or ((AreaTypology = '03') and (OtherAreaTypology = '08'))) or ((AreaTypology = '95') and ((OtherAreaTypology = '09') or (OtherAreaTypology = '10')))"
        >[Req 139] - La sottotipologia di area illuminata DEVE essere coerente con la tipologia di
        area illuminata.</sch:assert>

      <sch:assert
        test="not(AreaTypology = '01') or ((not(OtherLightSpotAllocation) or (OtherLightSpotAllocation[@xsi:nil = 'true'])))"
        flag="fatal">[Req 77] - Se la tipologia di area illuminata (AreaTypology) è uguale a 'area
        di circolazione veicolare', l'elemento 'altra distribuzione degli apparecchi'
        (OtherLightSpotAllocation) NON DEVE essere presente o, se presente, DEVE assumere il valore
        nullo.</sch:assert>

      <sch:assert test="(number(NumberOfLightSpotDevices) >= number(NumberOfSupports))" flag="fatal"
        >[Req 81] - Il numero totale apparecchi (NumberOfLightSpotDevices) DEVE essere maggiore o
        uguale al numero totale dei sostegni (NumberOfSupports).</sch:assert>

      <sch:assert
        test="(number(NumberOfLightSpotDevices) = count(LightSpotDeviceRefs/LightSpotDeviceID))"
        flag="fatal">[Req 82] - Il numero totale apparecchi (NumberOfLightSpotDevices) DEVE essere
        uguale al numero di identificativi di punti luce apparecchio (LightSpotDeviceID) indicati
        nella zona omogenea.</sch:assert>

      <sch:assert
        test="((Footpath = '02') or (not(OtherFootpathWidth) or (OtherFootpathWidth[@xsi:nil = 'true']))) and (not(number(OtherFootpathWidth) = number(FootpathWidth)))"
        flag="fatal">[Req 84] - La larghezza altro marciapiede (OtherFootpathWidth) non DEVE essere
        valorizzata in caso di opzione presenza di marciapiede (Footpath) diversa da "sì, su ambo i
        lati" o valore uguale a "larghezza marciapiede" (FootpathWidth).</sch:assert>

    </sch:rule>

    <sch:rule context="//gml:Point">
      <sch:assert
        test="(@srsDimension) and not(@srsDimension = '') and (@srsName) and not(@srsName = '') and (not(normalize-space(.) = ''))"
        flag="fatal">[Req 122] - Il Punto geografico e i suoi attributi 'srsDimension' e 'srsName'
        DEVONO essere forniti e valorizzati.</sch:assert>
    </sch:rule>


    <sch:rule context="//gml:Polygon">
      <sch:assert test="(@srsName) and not(@srsName = '') and (not(normalize-space(.) = ''))"
        flag="fatal">[Req 124] - L'Area geografica e il suo attributo 'srsName' DEVE essere fornito
        e valorizzato.</sch:assert>
    </sch:rule>

    <sch:rule context="(//*)">
      <sch:assert
        test="((namespace-uri() = 'http://www.opengis.net/gml/3.2') and ((local-name() = 'pointMember') or (count(child::gml:*) &gt; 0))) or (.[@xsi:nil = 'true']) or (not(normalize-space(.) = ''))"
        flag="fatal">[Req 0] - Ogni elemento presente nel documento XML DEVE essere valorizzato o,
        se ammesso, settato a nullo. </sch:assert>

      <sch:assert test="not((@xsi:nil = 'true') and (exists(@uom)))" flag="warning">[Racc 0] - Se un
        elemento è settato a nullo, l'unità di misura NON DOVREBBE essere presente (verifica
        l'elemento <sch:value-of select="local-name()"/> con uom <sch:value-of select="@uom"
        />).</sch:assert>

    </sch:rule>

  </sch:pattern>

  <sch:properties>
    <sch:property id="NoStd"/>
  </sch:properties>

</sch:schema>
