Message-Id: <9506232248.AA00378@vader.lbl.gov>
Content-Type: text/plain
Mime-Version: 1.0 (NeXT Mail 3.3 v118.2)
From: David R. Quarrie <quarrie@vader.lbl.gov>
Date: Fri, 23 Jun 95 15:48:06 -0700
To: Jim Linnemann at MSU (517)355-3328 <LINNEMANN@jiml.pa.msu.edu>
Subject: colias.f90stub.f90
Reply-To: DRQuarrie@lbl.gov
References: <950623182859.2140012e@jiml.pa.msu.edu>

! colias.f90stub.f90

    MODULE F_Node_handler

        TYPE F_Node_handle
            PRIVATE
            INTEGER :: dummy ! Dummy to satisfy compiler
        END TYPE F_Node_handle

    END MODULE ! F_Node_handler

    MODULE F_Node_interface

        INTERFACE

! Constructor & Destructor

            FUNCTION F_Node_new( ) &
                RESULT ( new_result )
                USE F_Node_handler
                TYPE(F_Node_handle), POINTER :: new_result
            END FUNCTION ! F_Node_new
            SUBROUTINE F_Node_delete( handle )
                USE F_Node_handler
                TYPE(F_Node_handle), POINTER :: handle
            END SUBROUTINE ! F_Node_delete

! Attribute Accessors

            FUNCTION F_Node_numTypesChildren( handle ) &
                RESULT ( numTypesChildren_result )
                USE F_Node_handler
                INTEGER :: numTypesChildren_result
                TYPE(F_Node_handle), INTENT(IN) :: handle
            END FUNCTION ! F_Node_numTypesChildren

! Operations

            SUBROUTINE F_Node_addChild( handle, child )
                USE F_Node_handler
                TYPE(F_Node_handle), INTENT(IN) :: handle
                TYPE(F_Node_handle), INTENT(IN) :: child
            END SUBROUTINE ! F_Node_addChild
            SUBROUTINE F_Node_deleteSubtree( handle )
                USE F_Node_handler
                TYPE(F_Node_handle), INTENT(IN) :: handle
            END SUBROUTINE ! F_Node_deleteSubtree
            SUBROUTINE F_Node_deleteChildrenOfType( handle, type )
                USE F_Node_handler
                TYPE(F_Node_handle), INTENT(IN) :: handle
                CHARACTER (LEN=*), INTENT(IN) :: type
            END SUBROUTINE ! F_Node_deleteChildrenOfType
            FUNCTION F_Node_getChild( handle, type, index ) &
                RESULT ( getChild_result )
                USE F_Node_handler
                TYPE(F_Node_handle), POINTER :: getChild_result
                TYPE(F_Node_handle), INTENT(IN) :: handle
                CHARACTER (LEN=*), INTENT(IN) :: type
                INTEGER, INTENT(IN) :: index
            END FUNCTION ! F_Node_getChild
            FUNCTION F_Node_numChildren( handle, type ) &
                RESULT ( numChildren_result )
                USE F_Node_handler
                INTEGER :: numChildren_result
                TYPE(F_Node_handle), INTENT(IN) :: handle
                CHARACTER (LEN=*), INTENT(IN) :: type
            END FUNCTION ! F_Node_numChildren

        END INTERFACE

    END MODULE ! F_Node_interface

    MODULE F_Node_data

        TYPE F_Node
            INTEGER :: numTypesChildren
        END TYPE F_Node

        CONTAINS

            SUBROUTINE F_Node_toF90( src, dst )
                USE F_Node_interface
                USE F_Node_handler
                IMPLICIT NONE
                TYPE(F_Node_handle), POINTER :: src
                TYPE(F_Node) :: dst
                dst % numTypesChildren = F_Node_numTypesChildren( src )
                RETURN
            END SUBROUTINE ! F_Node_toF90

    END MODULE ! F_Node_data

    MODULE F_Node_module

        USE F_Node_handler
        USE F_Node_interface
        USE F_Node_data

    END MODULE ! F_Node_module

    MODULE DATColiasNode_handler

        TYPE DATColiasNode_handle
            PRIVATE
            INTEGER :: dummy ! Dummy to satisfy compiler
        END TYPE DATColiasNode_handle

    END MODULE ! DATColiasNode_handler

    MODULE DATColiasNode_interface

        INTERFACE

! Constructor & Destructor

            FUNCTION DATColiasNode_new( ) &
                RESULT ( new_result )
                USE DATColiasNode_handler
                TYPE(DATColiasNode_handle), POINTER :: new_result
            END FUNCTION ! DATColiasNode_new
            SUBROUTINE DATColiasNode_delete( handle )
                USE DATColiasNode_handler
                TYPE(DATColiasNode_handle), POINTER :: handle
            END SUBROUTINE ! DATColiasNode_delete

! Type casting from parent(s)

        FUNCTION DATColiasNode_from_F_Node( handle ) &
            RESULT ( fromParent_result )
            USE F_Node_handler
            USE DATColiasNode_handler
            TYPE(F_Node_handle), INTENT(IN) :: handle
            TYPE(DATColiasNode_handle), POINTER :: fromParent_result
        END FUNCTION ! DATColiasNode_from_F_Node

! Attribute Accessors

            FUNCTION DATColiasNode_version( handle ) &
                RESULT ( version_result )
                USE DATColiasNode_handler
                INTEGER :: version_result
                TYPE(DATColiasNode_handle), INTENT(IN) :: handle
            END FUNCTION ! DATColiasNode_version

! Attribute Modifiers

            SUBROUTINE DATColiasNode_setVersion( handle, version )
                USE DATColiasNode_handler
                TYPE(DATColiasNode_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: version
            END SUBROUTINE ! DATColiasNode_setVersion

        END INTERFACE

    END MODULE ! DATColiasNode_interface

    MODULE DATColiasNode_data

        TYPE DATColiasNode
            INTEGER :: version
        END TYPE DATColiasNode

        CONTAINS

            SUBROUTINE DATColiasNode_toF90( src, dst )
                USE DATColiasNode_interface
                USE DATColiasNode_handler
                IMPLICIT NONE
                TYPE(DATColiasNode_handle), POINTER :: src
                TYPE(DATColiasNode) :: dst
                dst % version = DATColiasNode_version( src )
                RETURN
            END SUBROUTINE ! DATColiasNode_toF90

            SUBROUTINE DATColiasNode_fromF90( src, dst )
                USE DATColiasNode_interface
                USE DATColiasNode_handler
                IMPLICIT NONE
                TYPE(DATColiasNode) :: src
                TYPE(DATColiasNode_handle), POINTER :: dst
                CALL DATColiasNode_setVersion( dst, src % version )
                RETURN
            END SUBROUTINE ! DATColiasNode_fromF90

    END MODULE ! DATColiasNode_data

    MODULE DATColiasNode_module

        USE DATColiasNode_handler
        USE DATColiasNode_interface
        USE DATColiasNode_data

    END MODULE ! DATColiasNode_module

    MODULE DATEventNode_handler

        CHARACTER (LEN=*), PARAMETER :: DATEventNode_type = "Evnt"

        TYPE DATEventNode_handle
            PRIVATE
            INTEGER :: dummy ! Dummy to satisfy compiler
        END TYPE DATEventNode_handle

    END MODULE ! DATEventNode_handler

    MODULE DATEventNode_interface

        INTERFACE

! Constructor & Destructor

            FUNCTION DATEventNode_new( ) &
                RESULT ( new_result )
                USE DATEventNode_handler
                TYPE(DATEventNode_handle), POINTER :: new_result
            END FUNCTION ! DATEventNode_new
            SUBROUTINE DATEventNode_delete( handle )
                USE DATEventNode_handler
                TYPE(DATEventNode_handle), POINTER :: handle
            END SUBROUTINE ! DATEventNode_delete

! Type casting from parent(s)

        FUNCTION DATEventNode_from_F_Node( handle ) &
            RESULT ( fromParent_result )
            USE F_Node_handler
            USE DATEventNode_handler
            TYPE(F_Node_handle), INTENT(IN) :: handle
            TYPE(DATEventNode_handle), POINTER :: fromParent_result
        END FUNCTION ! DATEventNode_from_F_Node
        FUNCTION DATEventNode_from_DATColiasNode( handle ) &
            RESULT ( fromParent_result )
            USE DATColiasNode_handler
            USE DATEventNode_handler
            TYPE(DATColiasNode_handle), INTENT(IN) :: handle
            TYPE(DATEventNode_handle), POINTER :: fromParent_result
        END FUNCTION ! DATEventNode_from_DATColiasNode

! Attribute Accessors

            FUNCTION DATEventNode_run( handle ) &
                RESULT ( run_result )
                USE DATEventNode_handler
                INTEGER :: run_result
                TYPE(DATEventNode_handle), INTENT(IN) :: handle
            END FUNCTION ! DATEventNode_run
            FUNCTION DATEventNode_record( handle ) &
                RESULT ( record_result )
                USE DATEventNode_handler
                INTEGER :: record_result
                TYPE(DATEventNode_handle), INTENT(IN) :: handle
            END FUNCTION ! DATEventNode_record
            FUNCTION DATEventNode_date( handle ) &
                RESULT ( date_result )
                USE DATEventNode_handler
                INTEGER :: date_result
                TYPE(DATEventNode_handle), INTENT(IN) :: handle
            END FUNCTION ! DATEventNode_date
            FUNCTION DATEventNode_time( handle ) &
                RESULT ( time_result )
                USE DATEventNode_handler
                INTEGER :: time_result
                TYPE(DATEventNode_handle), INTENT(IN) :: handle
            END FUNCTION ! DATEventNode_time
            FUNCTION DATEventNode_eventType( handle ) &
                RESULT ( eventType_result )
                USE DATEventNode_handler
                INTEGER :: eventType_result
                TYPE(DATEventNode_handle), INTENT(IN) :: handle
            END FUNCTION ! DATEventNode_eventType

! Attribute Modifiers

            SUBROUTINE DATEventNode_setRun( handle, run )
                USE DATEventNode_handler
                TYPE(DATEventNode_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: run
            END SUBROUTINE ! DATEventNode_setRun
            SUBROUTINE DATEventNode_setRecord( handle, record )
                USE DATEventNode_handler
                TYPE(DATEventNode_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: record
            END SUBROUTINE ! DATEventNode_setRecord
            SUBROUTINE DATEventNode_setDate( handle, date )
                USE DATEventNode_handler
                TYPE(DATEventNode_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: date
            END SUBROUTINE ! DATEventNode_setDate
            SUBROUTINE DATEventNode_setTime( handle, time )
                USE DATEventNode_handler
                TYPE(DATEventNode_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: time
            END SUBROUTINE ! DATEventNode_setTime
            SUBROUTINE DATEventNode_setEventType( handle, eventType )
                USE DATEventNode_handler
                TYPE(DATEventNode_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: eventType
            END SUBROUTINE ! DATEventNode_setEventType

        END INTERFACE

    END MODULE ! DATEventNode_interface

    MODULE DATEventNode_data

        TYPE DATEventNode
            INTEGER :: run
            INTEGER :: record
            INTEGER :: date
            INTEGER :: time
            INTEGER :: eventType
        END TYPE DATEventNode

        CONTAINS

            SUBROUTINE DATEventNode_toF90( src, dst )
                USE DATEventNode_interface
                USE DATEventNode_handler
                IMPLICIT NONE
                TYPE(DATEventNode_handle), POINTER :: src
                TYPE(DATEventNode) :: dst
                dst % run       = DATEventNode_run      ( src )
                dst % record    = DATEventNode_record   ( src )
                dst % date      = DATEventNode_date     ( src )
                dst % time      = DATEventNode_time     ( src )
                dst % eventType = DATEventNode_eventType( src )
                RETURN
            END SUBROUTINE ! DATEventNode_toF90

            SUBROUTINE DATEventNode_fromF90( src, dst )
                USE DATEventNode_interface
                USE DATEventNode_handler
                IMPLICIT NONE
                TYPE(DATEventNode) :: src
                TYPE(DATEventNode_handle), POINTER :: dst
                CALL DATEventNode_setRun      ( dst, src % run       )
                CALL DATEventNode_setRecord   ( dst, src % record    )
                CALL DATEventNode_setDate     ( dst, src % date      )
                CALL DATEventNode_setTime     ( dst, src % time      )
                CALL DATEventNode_setEventType( dst, src % eventType )
                RETURN
            END SUBROUTINE ! DATEventNode_fromF90

    END MODULE ! DATEventNode_data

    MODULE DATEventNode_module

        USE DATEventNode_handler
        USE DATEventNode_interface
        USE DATEventNode_data

    END MODULE ! DATEventNode_module

    MODULE DATFileNode_handler

        CHARACTER (LEN=*), PARAMETER :: DATFileNode_type = "File"

        TYPE DATFileNode_handle
            PRIVATE
            INTEGER :: dummy ! Dummy to satisfy compiler
        END TYPE DATFileNode_handle

    END MODULE ! DATFileNode_handler

    MODULE DATFileNode_interface

        INTERFACE

! Constructor & Destructor

            FUNCTION DATFileNode_new( ) &
                RESULT ( new_result )
                USE DATFileNode_handler
                TYPE(DATFileNode_handle), POINTER :: new_result
            END FUNCTION ! DATFileNode_new
            SUBROUTINE DATFileNode_delete( handle )
                USE DATFileNode_handler
                TYPE(DATFileNode_handle), POINTER :: handle
            END SUBROUTINE ! DATFileNode_delete

! Type casting from parent(s)

        FUNCTION DATFileNode_from_F_Node( handle ) &
            RESULT ( fromParent_result )
            USE F_Node_handler
            USE DATFileNode_handler
            TYPE(F_Node_handle), INTENT(IN) :: handle
            TYPE(DATFileNode_handle), POINTER :: fromParent_result
        END FUNCTION ! DATFileNode_from_F_Node
        FUNCTION DATFileNode_from_DATColiasNode( handle ) &
            RESULT ( fromParent_result )
            USE DATColiasNode_handler
            USE DATFileNode_handler
            TYPE(DATColiasNode_handle), INTENT(IN) :: handle
            TYPE(DATFileNode_handle), POINTER :: fromParent_result
        END FUNCTION ! DATFileNode_from_DATColiasNode

! Attribute Accessors

            FUNCTION DATFileNode_date( handle ) &
                RESULT ( date_result )
                USE DATFileNode_handler
                INTEGER :: date_result
                TYPE(DATFileNode_handle), INTENT(IN) :: handle
            END FUNCTION ! DATFileNode_date
            FUNCTION DATFileNode_time( handle ) &
                RESULT ( time_result )
                USE DATFileNode_handler
                INTEGER :: time_result
                TYPE(DATFileNode_handle), INTENT(IN) :: handle
            END FUNCTION ! DATFileNode_time
            FUNCTION DATFileNode_program( handle ) &
                RESULT ( program_result )
                USE DATFileNode_handler
                CHARACTER (LEN=256) :: program_result
                TYPE(DATFileNode_handle), INTENT(IN) :: handle
            END FUNCTION ! DATFileNode_program
            FUNCTION DATFileNode_user( handle ) &
                RESULT ( user_result )
                USE DATFileNode_handler
                CHARACTER (LEN=256) :: user_result
                TYPE(DATFileNode_handle), INTENT(IN) :: handle
            END FUNCTION ! DATFileNode_user

! Attribute Modifiers

            SUBROUTINE DATFileNode_setDate( handle, date )
                USE DATFileNode_handler
                TYPE(DATFileNode_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: date
            END SUBROUTINE ! DATFileNode_setDate
            SUBROUTINE DATFileNode_setTime( handle, time )
                USE DATFileNode_handler
                TYPE(DATFileNode_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: time
            END SUBROUTINE ! DATFileNode_setTime
            SUBROUTINE DATFileNode_setProgram( handle, program )
                USE DATFileNode_handler
                TYPE(DATFileNode_handle), INTENT(IN) :: handle
                CHARACTER (LEN=*), INTENT(IN) :: program
            END SUBROUTINE ! DATFileNode_setProgram
            SUBROUTINE DATFileNode_setUser( handle, user )
                USE DATFileNode_handler
                TYPE(DATFileNode_handle), INTENT(IN) :: handle
                CHARACTER (LEN=*), INTENT(IN) :: user
            END SUBROUTINE ! DATFileNode_setUser

        END INTERFACE

    END MODULE ! DATFileNode_interface

    MODULE DATFileNode_data

        TYPE DATFileNode
            INTEGER :: date
            INTEGER :: time
            CHARACTER (LEN=256) :: program
            CHARACTER (LEN=256) :: user
        END TYPE DATFileNode

        CONTAINS

            SUBROUTINE DATFileNode_toF90( src, dst )
                USE DATFileNode_interface
                USE DATFileNode_handler
                IMPLICIT NONE
                TYPE(DATFileNode_handle), POINTER :: src
                TYPE(DATFileNode) :: dst
                dst % date    = DATFileNode_date   ( src )
                dst % time    = DATFileNode_time   ( src )
                dst % program = DATFileNode_program( src )
                dst % user    = DATFileNode_user   ( src )
                RETURN
            END SUBROUTINE ! DATFileNode_toF90

            SUBROUTINE DATFileNode_fromF90( src, dst )
                USE DATFileNode_interface
                USE DATFileNode_handler
                IMPLICIT NONE
                TYPE(DATFileNode) :: src
                TYPE(DATFileNode_handle), POINTER :: dst
                CALL DATFileNode_setDate   ( dst, src % date    )
                CALL DATFileNode_setTime   ( dst, src % time    )
                CALL DATFileNode_setProgram( dst, src % program )
                CALL DATFileNode_setUser   ( dst, src % user    )
                RETURN
            END SUBROUTINE ! DATFileNode_fromF90

    END MODULE ! DATFileNode_data

    MODULE DATFileNode_module

        USE DATFileNode_handler
        USE DATFileNode_interface
        USE DATFileNode_data

    END MODULE ! DATFileNode_module

    MODULE DATHitsNode_handler

        CHARACTER (LEN=*), PARAMETER :: DATHitsNode_type = "Hits"

        TYPE DATHitsNode_handle
            PRIVATE
            INTEGER :: dummy ! Dummy to satisfy compiler
        END TYPE DATHitsNode_handle

    END MODULE ! DATHitsNode_handler

    MODULE DATHitsNode_interface

        INTERFACE

! Constructor & Destructor

            FUNCTION DATHitsNode_new( ) &
                RESULT ( new_result )
                USE DATHitsNode_handler
                TYPE(DATHitsNode_handle), POINTER :: new_result
            END FUNCTION ! DATHitsNode_new
            SUBROUTINE DATHitsNode_delete( handle )
                USE DATHitsNode_handler
                TYPE(DATHitsNode_handle), POINTER :: handle
            END SUBROUTINE ! DATHitsNode_delete

! Type casting from parent(s)

        FUNCTION DATHitsNode_from_F_Node( handle ) &
            RESULT ( fromParent_result )
            USE F_Node_handler
            USE DATHitsNode_handler
            TYPE(F_Node_handle), INTENT(IN) :: handle
            TYPE(DATHitsNode_handle), POINTER :: fromParent_result
        END FUNCTION ! DATHitsNode_from_F_Node
        FUNCTION DATHitsNode_from_DATColiasNode( handle ) &
            RESULT ( fromParent_result )
            USE DATColiasNode_handler
            USE DATHitsNode_handler
            TYPE(DATColiasNode_handle), INTENT(IN) :: handle
            TYPE(DATHitsNode_handle), POINTER :: fromParent_result
        END FUNCTION ! DATHitsNode_from_DATColiasNode

        END INTERFACE

    END MODULE ! DATHitsNode_interface

    MODULE DATHitsNode_data

        TYPE DATHitsNode
            INTEGER :: dummy ! Dummy to satisfy compiler
        END TYPE DATHitsNode

    END MODULE ! DATHitsNode_data

    MODULE DATHitsNode_module

        USE DATHitsNode_handler
        USE DATHitsNode_interface
        USE DATHitsNode_data

    END MODULE ! DATHitsNode_module

    MODULE DATSimNode_handler

        CHARACTER (LEN=*), PARAMETER :: DATSimNode_type = "SimD"

        TYPE DATSimNode_handle
            PRIVATE
            INTEGER :: dummy ! Dummy to satisfy compiler
        END TYPE DATSimNode_handle

    END MODULE ! DATSimNode_handler

    MODULE DATSimNode_interface

        INTERFACE

! Constructor & Destructor

            FUNCTION DATSimNode_new( ) &
                RESULT ( new_result )
                USE DATSimNode_handler
                TYPE(DATSimNode_handle), POINTER :: new_result
            END FUNCTION ! DATSimNode_new
            SUBROUTINE DATSimNode_delete( handle )
                USE DATSimNode_handler
                TYPE(DATSimNode_handle), POINTER :: handle
            END SUBROUTINE ! DATSimNode_delete

! Type casting from parent(s)

        FUNCTION DATSimNode_from_F_Node( handle ) &
            RESULT ( fromParent_result )
            USE F_Node_handler
            USE DATSimNode_handler
            TYPE(F_Node_handle), INTENT(IN) :: handle
            TYPE(DATSimNode_handle), POINTER :: fromParent_result
        END FUNCTION ! DATSimNode_from_F_Node
        FUNCTION DATSimNode_from_DATColiasNode( handle ) &
            RESULT ( fromParent_result )
            USE DATColiasNode_handler
            USE DATSimNode_handler
            TYPE(DATColiasNode_handle), INTENT(IN) :: handle
            TYPE(DATSimNode_handle), POINTER :: fromParent_result
        END FUNCTION ! DATSimNode_from_DATColiasNode

        END INTERFACE

    END MODULE ! DATSimNode_interface

    MODULE DATSimNode_data

        TYPE DATSimNode
            INTEGER :: dummy ! Dummy to satisfy compiler
        END TYPE DATSimNode

    END MODULE ! DATSimNode_data

    MODULE DATSimNode_module

        USE DATSimNode_handler
        USE DATSimNode_interface
        USE DATSimNode_data

    END MODULE ! DATSimNode_module

    MODULE DATRawDataNode_handler

        CHARACTER (LEN=*), PARAMETER :: DATRawDataNode_type = "RawD"

        TYPE DATRawDataNode_handle
            PRIVATE
            INTEGER :: dummy ! Dummy to satisfy compiler
        END TYPE DATRawDataNode_handle

    END MODULE ! DATRawDataNode_handler

    MODULE DATRawDataNode_interface

        INTERFACE

! Constructor & Destructor

            FUNCTION DATRawDataNode_new( ) &
                RESULT ( new_result )
                USE DATRawDataNode_handler
                TYPE(DATRawDataNode_handle), POINTER :: new_result
            END FUNCTION ! DATRawDataNode_new
            SUBROUTINE DATRawDataNode_delete( handle )
                USE DATRawDataNode_handler
                TYPE(DATRawDataNode_handle), POINTER :: handle
            END SUBROUTINE ! DATRawDataNode_delete

! Type casting from parent(s)

        FUNCTION DATRawDataNode_from_F_Node( handle ) &
            RESULT ( fromParent_result )
            USE F_Node_handler
            USE DATRawDataNode_handler
            TYPE(F_Node_handle), INTENT(IN) :: handle
            TYPE(DATRawDataNode_handle), POINTER :: fromParent_result
        END FUNCTION ! DATRawDataNode_from_F_Node
        FUNCTION DATRawDataNode_from_DATColiasNo( handle ) &
            RESULT ( fromParent_result )
            USE DATColiasNode_handler
            USE DATRawDataNode_handler
            TYPE(DATColiasNode_handle), INTENT(IN) :: handle
            TYPE(DATRawDataNode_handle), POINTER :: fromParent_result
        END FUNCTION ! DATRawDataNode_from_DATColiasNo

        END INTERFACE

    END MODULE ! DATRawDataNode_interface

    MODULE DATRawDataNode_data

        TYPE DATRawDataNode
            INTEGER :: dummy ! Dummy to satisfy compiler
        END TYPE DATRawDataNode

    END MODULE ! DATRawDataNode_data

    MODULE DATRawDataNode_module

        USE DATRawDataNode_handler
        USE DATRawDataNode_interface
        USE DATRawDataNode_data

    END MODULE ! DATRawDataNode_module

    MODULE DATEMCDigi_handler

        TYPE DATEMCDigi_handle
            PRIVATE
            INTEGER :: dummy ! Dummy to satisfy compiler
        END TYPE DATEMCDigi_handle

    END MODULE ! DATEMCDigi_handler

    MODULE DATEMCDigi_interface

        INTERFACE

! Constructor & Destructor

            FUNCTION DATEMCDigi_new( ) &
                RESULT ( new_result )
                USE DATEMCDigi_handler
                TYPE(DATEMCDigi_handle), POINTER :: new_result
            END FUNCTION ! DATEMCDigi_new
            SUBROUTINE DATEMCDigi_delete( handle )
                USE DATEMCDigi_handler
                TYPE(DATEMCDigi_handle), POINTER :: handle
            END SUBROUTINE ! DATEMCDigi_delete

! Attribute Accessors

            FUNCTION DATEMCDigi_channel( handle ) &
                RESULT ( channel_result )
                USE DATEMCDigi_handler
                INTEGER :: channel_result
                TYPE(DATEMCDigi_handle), INTENT(IN) :: handle
            END FUNCTION ! DATEMCDigi_channel
            FUNCTION DATEMCDigi_timeStamp( handle ) &
                RESULT ( timeStamp_result )
                USE DATEMCDigi_handler
                INTEGER :: timeStamp_result
                TYPE(DATEMCDigi_handle), INTENT(IN) :: handle
            END FUNCTION ! DATEMCDigi_timeStamp
            FUNCTION DATEMCDigi_pulseHeight( handle ) &
                RESULT ( pulseHeight_result )
                USE DATEMCDigi_handler
                INTEGER :: pulseHeight_result
                TYPE(DATEMCDigi_handle), INTENT(IN) :: handle
            END FUNCTION ! DATEMCDigi_pulseHeight

! Attribute Modifiers

            SUBROUTINE DATEMCDigi_setChannel( handle, channel )
                USE DATEMCDigi_handler
                TYPE(DATEMCDigi_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: channel
            END SUBROUTINE ! DATEMCDigi_setChannel
            SUBROUTINE DATEMCDigi_setTimeStamp( handle, timeStamp )
                USE DATEMCDigi_handler
                TYPE(DATEMCDigi_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: timeStamp
            END SUBROUTINE ! DATEMCDigi_setTimeStamp
            SUBROUTINE DATEMCDigi_setPulseHeight( handle, pulseHeight )
                USE DATEMCDigi_handler
                TYPE(DATEMCDigi_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: pulseHeight
            END SUBROUTINE ! DATEMCDigi_setPulseHeight

        END INTERFACE

    END MODULE ! DATEMCDigi_interface

    MODULE DATEMCDigi_data

        TYPE DATEMCDigi
            INTEGER :: channel
            INTEGER :: timeStamp
            INTEGER :: pulseHeight
        END TYPE DATEMCDigi

        CONTAINS

            SUBROUTINE DATEMCDigi_toF90( src, dst )
                USE DATEMCDigi_interface
                USE DATEMCDigi_handler
                IMPLICIT NONE
                TYPE(DATEMCDigi_handle), POINTER :: src
                TYPE(DATEMCDigi) :: dst
                dst % channel     = DATEMCDigi_channel    ( src )
                dst % timeStamp   = DATEMCDigi_timeStamp  ( src )
                dst % pulseHeight = DATEMCDigi_pulseHeight( src )
                RETURN
            END SUBROUTINE ! DATEMCDigi_toF90

            SUBROUTINE DATEMCDigi_fromF90( src, dst )
                USE DATEMCDigi_interface
                USE DATEMCDigi_handler
                IMPLICIT NONE
                TYPE(DATEMCDigi) :: src
                TYPE(DATEMCDigi_handle), POINTER :: dst
                CALL DATEMCDigi_setChannel    ( dst, src % channel     )
                CALL DATEMCDigi_setTimeStamp  ( dst, src % timeStamp   )
                CALL DATEMCDigi_setPulseHeight( dst, src % pulseHeight )
                RETURN
            END SUBROUTINE ! DATEMCDigi_fromF90

    END MODULE ! DATEMCDigi_data

    MODULE DATEMCDigi_module

        USE DATEMCDigi_handler
        USE DATEMCDigi_interface
        USE DATEMCDigi_data

    END MODULE ! DATEMCDigi_module

    MODULE DATEMCRawNode_handler

        CHARACTER (LEN=*), PARAMETER :: DATEMCRawNode_type = "EmcR"

        TYPE DATEMCRawNode_handle
            PRIVATE
            INTEGER :: dummy ! Dummy to satisfy compiler
        END TYPE DATEMCRawNode_handle

    END MODULE ! DATEMCRawNode_handler

    MODULE DATEMCRawNode_interface

        INTERFACE

! Constructor & Destructor

            FUNCTION DATEMCRawNode_new( ) &
                RESULT ( new_result )
                USE DATEMCRawNode_handler
                USE DATEMCDigi_handler
                TYPE(DATEMCRawNode_handle), POINTER :: new_result
            END FUNCTION ! DATEMCRawNode_new
            SUBROUTINE DATEMCRawNode_delete( handle )
                USE DATEMCRawNode_handler
                USE DATEMCDigi_handler
                TYPE(DATEMCRawNode_handle), POINTER :: handle
            END SUBROUTINE ! DATEMCRawNode_delete

! Type casting from parent(s)

        FUNCTION DATEMCRawNode_from_F_Node( handle ) &
            RESULT ( fromParent_result )
            USE F_Node_handler
            USE DATEMCRawNode_handler
            TYPE(F_Node_handle), INTENT(IN) :: handle
            TYPE(DATEMCRawNode_handle), POINTER :: fromParent_result
        END FUNCTION ! DATEMCRawNode_from_F_Node
        FUNCTION DATEMCRawNode_from_DATColiasNod( handle ) &
            RESULT ( fromParent_result )
            USE DATColiasNode_handler
            USE DATEMCRawNode_handler
            TYPE(DATColiasNode_handle), INTENT(IN) :: handle
            TYPE(DATEMCRawNode_handle), POINTER :: fromParent_result
        END FUNCTION ! DATEMCRawNode_from_DATColiasNod

! Attribute Accessors

            FUNCTION DATEMCRawNode_nDigis( handle ) &
                RESULT ( nDigis_result )
                USE DATEMCRawNode_handler
                USE DATEMCDigi_handler
                INTEGER :: nDigis_result
                TYPE(DATEMCRawNode_handle), INTENT(IN) :: handle
            END FUNCTION ! DATEMCRawNode_nDigis

! Operations

            FUNCTION DATEMCRawNode_digi( handle, index ) &
                RESULT ( digi_result )
                USE DATEMCRawNode_handler
                USE DATEMCDigi_handler
                TYPE(DATEMCDigi_handle), POINTER :: digi_result
                TYPE(DATEMCRawNode_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: index
            END FUNCTION ! DATEMCRawNode_digi

        END INTERFACE

    END MODULE ! DATEMCRawNode_interface

    MODULE DATEMCRawNode_data

        TYPE DATEMCRawNode
            INTEGER :: nDigis
        END TYPE DATEMCRawNode

        CONTAINS

            SUBROUTINE DATEMCRawNode_toF90( src, dst )
                USE DATEMCRawNode_interface
                USE DATEMCRawNode_handler
                USE DATEMCDigi_handler
                IMPLICIT NONE
                TYPE(DATEMCRawNode_handle), POINTER :: src
                TYPE(DATEMCRawNode) :: dst
                dst % nDigis = DATEMCRawNode_nDigis( src )
                RETURN
            END SUBROUTINE ! DATEMCRawNode_toF90

    END MODULE ! DATEMCRawNode_data

    MODULE DATEMCRawNode_module

        USE DATEMCRawNode_handler
        USE DATEMCRawNode_interface
        USE DATEMCRawNode_data

    END MODULE ! DATEMCRawNode_module

    MODULE DATSVTDigi_handler

        TYPE DATSVTDigi_handle
            PRIVATE
            INTEGER :: dummy ! Dummy to satisfy compiler
        END TYPE DATSVTDigi_handle

    END MODULE ! DATSVTDigi_handler

    MODULE DATSVTDigi_interface

        INTERFACE

! Constructor & Destructor

            FUNCTION DATSVTDigi_new( ) &
                RESULT ( new_result )
                USE DATSVTDigi_handler
                TYPE(DATSVTDigi_handle), POINTER :: new_result
            END FUNCTION ! DATSVTDigi_new
            SUBROUTINE DATSVTDigi_delete( handle )
                USE DATSVTDigi_handler
                TYPE(DATSVTDigi_handle), POINTER :: handle
            END SUBROUTINE ! DATSVTDigi_delete

! Attribute Accessors

            FUNCTION DATSVTDigi_channel( handle ) &
                RESULT ( channel_result )
                USE DATSVTDigi_handler
                INTEGER :: channel_result
                TYPE(DATSVTDigi_handle), INTENT(IN) :: handle
            END FUNCTION ! DATSVTDigi_channel
            FUNCTION DATSVTDigi_chip( handle ) &
                RESULT ( chip_result )
                USE DATSVTDigi_handler
                INTEGER :: chip_result
                TYPE(DATSVTDigi_handle), INTENT(IN) :: handle
            END FUNCTION ! DATSVTDigi_chip
            FUNCTION DATSVTDigi_errorFlag( handle ) &
                RESULT ( errorFlag_result )
                USE DATSVTDigi_handler
                INTEGER :: errorFlag_result
                TYPE(DATSVTDigi_handle), INTENT(IN) :: handle
            END FUNCTION ! DATSVTDigi_errorFlag
            FUNCTION DATSVTDigi_readoutSection( handle ) &
                RESULT ( readoutSection_result )
                USE DATSVTDigi_handler
                INTEGER :: readoutSection_result
                TYPE(DATSVTDigi_handle), INTENT(IN) :: handle
            END FUNCTION ! DATSVTDigi_readoutSection
            FUNCTION DATSVTDigi_timeOverThresh( handle ) &
                RESULT ( timeOverThresh_result )
                USE DATSVTDigi_handler
                INTEGER :: timeOverThresh_result
                TYPE(DATSVTDigi_handle), INTENT(IN) :: handle
            END FUNCTION ! DATSVTDigi_timeOverThresh
            FUNCTION DATSVTDigi_timeStamp( handle ) &
                RESULT ( timeStamp_result )
                USE DATSVTDigi_handler
                INTEGER :: timeStamp_result
                TYPE(DATSVTDigi_handle), INTENT(IN) :: handle
            END FUNCTION ! DATSVTDigi_timeStamp

! Attribute Modifiers

            SUBROUTINE DATSVTDigi_setChannel( handle, channel )
                USE DATSVTDigi_handler
                TYPE(DATSVTDigi_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: channel
            END SUBROUTINE ! DATSVTDigi_setChannel
            SUBROUTINE DATSVTDigi_setChip( handle, chip )
                USE DATSVTDigi_handler
                TYPE(DATSVTDigi_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: chip
            END SUBROUTINE ! DATSVTDigi_setChip
            SUBROUTINE DATSVTDigi_setErrorFlag( handle, errorFlag )
                USE DATSVTDigi_handler
                TYPE(DATSVTDigi_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: errorFlag
            END SUBROUTINE ! DATSVTDigi_setErrorFlag
            SUBROUTINE DATSVTDigi_setReadoutSection( handle,  
readoutSection )
                USE DATSVTDigi_handler
                TYPE(DATSVTDigi_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: readoutSection
            END SUBROUTINE ! DATSVTDigi_setReadoutSection
            SUBROUTINE DATSVTDigi_setTimeOverThresh( handle,  
timeOverThresh )
                USE DATSVTDigi_handler
                TYPE(DATSVTDigi_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: timeOverThresh
            END SUBROUTINE ! DATSVTDigi_setTimeOverThresh
            SUBROUTINE DATSVTDigi_setTimeStamp( handle, timeStamp )
                USE DATSVTDigi_handler
                TYPE(DATSVTDigi_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: timeStamp
            END SUBROUTINE ! DATSVTDigi_setTimeStamp

        END INTERFACE

    END MODULE ! DATSVTDigi_interface

    MODULE DATSVTDigi_data

        TYPE DATSVTDigi
            INTEGER :: channel
            INTEGER :: chip
            INTEGER :: errorFlag
            INTEGER :: readoutSection
            INTEGER :: timeOverThresh
            INTEGER :: timeStamp
        END TYPE DATSVTDigi

        CONTAINS

            SUBROUTINE DATSVTDigi_toF90( src, dst )
                USE DATSVTDigi_interface
                USE DATSVTDigi_handler
                IMPLICIT NONE
                TYPE(DATSVTDigi_handle), POINTER :: src
                TYPE(DATSVTDigi) :: dst
                dst % channel        = DATSVTDigi_channel       ( src )
                dst % chip           = DATSVTDigi_chip          ( src )
                dst % errorFlag      = DATSVTDigi_errorFlag     ( src )
                dst % readoutSection = DATSVTDigi_readoutSection( src )
                dst % timeOverThresh = DATSVTDigi_timeOverThresh( src )
                dst % timeStamp      = DATSVTDigi_timeStamp     ( src )
                RETURN
            END SUBROUTINE ! DATSVTDigi_toF90

            SUBROUTINE DATSVTDigi_fromF90( src, dst )
                USE DATSVTDigi_interface
                USE DATSVTDigi_handler
                IMPLICIT NONE
                TYPE(DATSVTDigi) :: src
                TYPE(DATSVTDigi_handle), POINTER :: dst
                CALL DATSVTDigi_setChannel       ( dst, src %  
channel        )
                CALL DATSVTDigi_setChip          ( dst, src % chip   
         )
                CALL DATSVTDigi_setErrorFlag     ( dst, src %  
errorFlag      )
                CALL DATSVTDigi_setReadoutSection( dst, src %  
readoutSection )
                CALL DATSVTDigi_setTimeOverThresh( dst, src %  
timeOverThresh )
                CALL DATSVTDigi_setTimeStamp     ( dst, src %  
timeStamp      )
                RETURN
            END SUBROUTINE ! DATSVTDigi_fromF90

    END MODULE ! DATSVTDigi_data

    MODULE DATSVTDigi_module

        USE DATSVTDigi_handler
        USE DATSVTDigi_interface
        USE DATSVTDigi_data

    END MODULE ! DATSVTDigi_module

    MODULE DATSVTRawNode_handler

        CHARACTER (LEN=*), PARAMETER :: DATSVTRawNode_type = "SiSR"

        TYPE DATSVTRawNode_handle
            PRIVATE
            INTEGER :: dummy ! Dummy to satisfy compiler
        END TYPE DATSVTRawNode_handle

    END MODULE ! DATSVTRawNode_handler

    MODULE DATSVTRawNode_interface

        INTERFACE

! Constructor & Destructor

            FUNCTION DATSVTRawNode_new( ) &
                RESULT ( new_result )
                USE DATSVTRawNode_handler
                USE DATSVTDigi_handler
                TYPE(DATSVTRawNode_handle), POINTER :: new_result
            END FUNCTION ! DATSVTRawNode_new
            SUBROUTINE DATSVTRawNode_delete( handle )
                USE DATSVTRawNode_handler
                USE DATSVTDigi_handler
                TYPE(DATSVTRawNode_handle), POINTER :: handle
            END SUBROUTINE ! DATSVTRawNode_delete

! Type casting from parent(s)

        FUNCTION DATSVTRawNode_from_F_Node( handle ) &
            RESULT ( fromParent_result )
            USE F_Node_handler
            USE DATSVTRawNode_handler
            TYPE(F_Node_handle), INTENT(IN) :: handle
            TYPE(DATSVTRawNode_handle), POINTER :: fromParent_result
        END FUNCTION ! DATSVTRawNode_from_F_Node
        FUNCTION DATSVTRawNode_from_DATColiasNod( handle ) &
            RESULT ( fromParent_result )
            USE DATColiasNode_handler
            USE DATSVTRawNode_handler
            TYPE(DATColiasNode_handle), INTENT(IN) :: handle
            TYPE(DATSVTRawNode_handle), POINTER :: fromParent_result
        END FUNCTION ! DATSVTRawNode_from_DATColiasNod

! Attribute Accessors

            FUNCTION DATSVTRawNode_nDigis( handle ) &
                RESULT ( nDigis_result )
                USE DATSVTRawNode_handler
                USE DATSVTDigi_handler
                INTEGER :: nDigis_result
                TYPE(DATSVTRawNode_handle), INTENT(IN) :: handle
            END FUNCTION ! DATSVTRawNode_nDigis

! Operations

            FUNCTION DATSVTRawNode_digi( handle, index ) &
                RESULT ( digi_result )
                USE DATSVTRawNode_handler
                USE DATSVTDigi_handler
                TYPE(DATSVTDigi_handle), POINTER :: digi_result
                TYPE(DATSVTRawNode_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: index
            END FUNCTION ! DATSVTRawNode_digi

        END INTERFACE

    END MODULE ! DATSVTRawNode_interface

    MODULE DATSVTRawNode_data

        TYPE DATSVTRawNode
            INTEGER :: nDigis
        END TYPE DATSVTRawNode

        CONTAINS

            SUBROUTINE DATSVTRawNode_toF90( src, dst )
                USE DATSVTRawNode_interface
                USE DATSVTRawNode_handler
                USE DATSVTDigi_handler
                IMPLICIT NONE
                TYPE(DATSVTRawNode_handle), POINTER :: src
                TYPE(DATSVTRawNode) :: dst
                dst % nDigis = DATSVTRawNode_nDigis( src )
                RETURN
            END SUBROUTINE ! DATSVTRawNode_toF90

    END MODULE ! DATSVTRawNode_data

    MODULE DATSVTRawNode_module

        USE DATSVTRawNode_handler
        USE DATSVTRawNode_interface
        USE DATSVTRawNode_data

    END MODULE ! DATSVTRawNode_module

    MODULE DATDcHit_handler

        TYPE DATDcHit_handle
            PRIVATE
            INTEGER :: dummy ! Dummy to satisfy compiler
        END TYPE DATDcHit_handle

    END MODULE ! DATDcHit_handler

    MODULE DATDcHit_interface

        INTERFACE

! Constructor & Destructor

            FUNCTION DATDcHit_new( ) &
                RESULT ( new_result )
                USE DATDcHit_handler
                TYPE(DATDcHit_handle), POINTER :: new_result
            END FUNCTION ! DATDcHit_new
            SUBROUTINE DATDcHit_delete( handle )
                USE DATDcHit_handler
                TYPE(DATDcHit_handle), POINTER :: handle
            END SUBROUTINE ! DATDcHit_delete

! Attribute Accessors

            FUNCTION DATDcHit_dEdxPH( handle ) &
                RESULT ( dEdxPH_result )
                USE DATDcHit_handler
                REAL :: dEdxPH_result
                TYPE(DATDcHit_handle), INTENT(IN) :: handle
            END FUNCTION ! DATDcHit_dEdxPH
            FUNCTION DATDcHit_driftDistMid( handle ) &
                RESULT ( driftDistMid_result )
                USE DATDcHit_handler
                REAL :: driftDistMid_result
                TYPE(DATDcHit_handle), INTENT(IN) :: handle
            END FUNCTION ! DATDcHit_driftDistMid
            FUNCTION DATDcHit_layer( handle ) &
                RESULT ( layer_result )
                USE DATDcHit_handler
                INTEGER :: layer_result
                TYPE(DATDcHit_handle), INTENT(IN) :: handle
            END FUNCTION ! DATDcHit_layer
            FUNCTION DATDcHit_phiMid( handle ) &
                RESULT ( phiMid_result )
                USE DATDcHit_handler
                REAL :: phiMid_result
                TYPE(DATDcHit_handle), INTENT(IN) :: handle
            END FUNCTION ! DATDcHit_phiMid
            FUNCTION DATDcHit_rawHit( handle ) &
                RESULT ( rawHit_result )
                USE DATDcHit_handler
                INTEGER :: rawHit_result
                TYPE(DATDcHit_handle), INTENT(IN) :: handle
            END FUNCTION ! DATDcHit_rawHit
            FUNCTION DATDcHit_status( handle ) &
                RESULT ( status_result )
                USE DATDcHit_handler
                INTEGER :: status_result
                TYPE(DATDcHit_handle), INTENT(IN) :: handle
            END FUNCTION ! DATDcHit_status
            FUNCTION DATDcHit_wire( handle ) &
                RESULT ( wire_result )
                USE DATDcHit_handler
                INTEGER :: wire_result
                TYPE(DATDcHit_handle), INTENT(IN) :: handle
            END FUNCTION ! DATDcHit_wire

! Attribute Modifiers

            SUBROUTINE DATDcHit_setDEdxPH( handle, dEdxPH )
                USE DATDcHit_handler
                TYPE(DATDcHit_handle), INTENT(IN) :: handle
                REAL, INTENT(IN) :: dEdxPH
            END SUBROUTINE ! DATDcHit_setDEdxPH
            SUBROUTINE DATDcHit_setDriftDistMid( handle, driftDistMid )
                USE DATDcHit_handler
                TYPE(DATDcHit_handle), INTENT(IN) :: handle
                REAL, INTENT(IN) :: driftDistMid
            END SUBROUTINE ! DATDcHit_setDriftDistMid
            SUBROUTINE DATDcHit_setLayer( handle, layer )
                USE DATDcHit_handler
                TYPE(DATDcHit_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: layer
            END SUBROUTINE ! DATDcHit_setLayer
            SUBROUTINE DATDcHit_setPhiMid( handle, phiMid )
                USE DATDcHit_handler
                TYPE(DATDcHit_handle), INTENT(IN) :: handle
                REAL, INTENT(IN) :: phiMid
            END SUBROUTINE ! DATDcHit_setPhiMid
            SUBROUTINE DATDcHit_setRawHit( handle, rawHit )
                USE DATDcHit_handler
                TYPE(DATDcHit_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: rawHit
            END SUBROUTINE ! DATDcHit_setRawHit
            SUBROUTINE DATDcHit_setStatus( handle, status )
                USE DATDcHit_handler
                TYPE(DATDcHit_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: status
            END SUBROUTINE ! DATDcHit_setStatus
            SUBROUTINE DATDcHit_setWire( handle, wire )
                USE DATDcHit_handler
                TYPE(DATDcHit_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: wire
            END SUBROUTINE ! DATDcHit_setWire

        END INTERFACE

    END MODULE ! DATDcHit_interface

    MODULE DATDcHit_data

        TYPE DATDcHit
            REAL :: dEdxPH
            REAL :: driftDistMid
            INTEGER :: layer
            REAL :: phiMid
            INTEGER :: rawHit
            INTEGER :: status
            INTEGER :: wire
        END TYPE DATDcHit

        CONTAINS

            SUBROUTINE DATDcHit_toF90( src, dst )
                USE DATDcHit_interface
                USE DATDcHit_handler
                IMPLICIT NONE
                TYPE(DATDcHit_handle), POINTER :: src
                TYPE(DATDcHit) :: dst
                dst % dEdxPH       = DATDcHit_dEdxPH      ( src )
                dst % driftDistMid = DATDcHit_driftDistMid( src )
                dst % layer        = DATDcHit_layer       ( src )
                dst % phiMid       = DATDcHit_phiMid      ( src )
                dst % rawHit       = DATDcHit_rawHit      ( src )
                dst % status       = DATDcHit_status      ( src )
                dst % wire         = DATDcHit_wire        ( src )
                RETURN
            END SUBROUTINE ! DATDcHit_toF90

            SUBROUTINE DATDcHit_fromF90( src, dst )
                USE DATDcHit_interface
                USE DATDcHit_handler
                IMPLICIT NONE
                TYPE(DATDcHit) :: src
                TYPE(DATDcHit_handle), POINTER :: dst
                CALL DATDcHit_setDEdxPH      ( dst, src % dEdxPH       )
                CALL DATDcHit_setDriftDistMid( dst, src % driftDistMid )
                CALL DATDcHit_setLayer       ( dst, src % layer        )
                CALL DATDcHit_setPhiMid      ( dst, src % phiMid       )
                CALL DATDcHit_setRawHit      ( dst, src % rawHit       )
                CALL DATDcHit_setStatus      ( dst, src % status       )
                CALL DATDcHit_setWire        ( dst, src % wire         )
                RETURN
            END SUBROUTINE ! DATDcHit_fromF90

    END MODULE ! DATDcHit_data

    MODULE DATDcHit_module

        USE DATDcHit_handler
        USE DATDcHit_interface
        USE DATDcHit_data

    END MODULE ! DATDcHit_module

    MODULE DATDcHitsNode_handler

        CHARACTER (LEN=*), PARAMETER :: DATDcHitsNode_type = "DcHt"

        TYPE DATDcHitsNode_handle
            PRIVATE
            INTEGER :: dummy ! Dummy to satisfy compiler
        END TYPE DATDcHitsNode_handle

    END MODULE ! DATDcHitsNode_handler

    MODULE DATDcHitsNode_interface

        INTERFACE

! Constructor & Destructor

            FUNCTION DATDcHitsNode_new( ) &
                RESULT ( new_result )
                USE DATDcHitsNode_handler
                USE DATDcHit_handler
                TYPE(DATDcHitsNode_handle), POINTER :: new_result
            END FUNCTION ! DATDcHitsNode_new
            SUBROUTINE DATDcHitsNode_delete( handle )
                USE DATDcHitsNode_handler
                USE DATDcHit_handler
                TYPE(DATDcHitsNode_handle), POINTER :: handle
            END SUBROUTINE ! DATDcHitsNode_delete

! Type casting from parent(s)

        FUNCTION DATDcHitsNode_from_F_Node( handle ) &
            RESULT ( fromParent_result )
            USE F_Node_handler
            USE DATDcHitsNode_handler
            TYPE(F_Node_handle), INTENT(IN) :: handle
            TYPE(DATDcHitsNode_handle), POINTER :: fromParent_result
        END FUNCTION ! DATDcHitsNode_from_F_Node
        FUNCTION DATDcHitsNode_from_DATColiasNod( handle ) &
            RESULT ( fromParent_result )
            USE DATColiasNode_handler
            USE DATDcHitsNode_handler
            TYPE(DATColiasNode_handle), INTENT(IN) :: handle
            TYPE(DATDcHitsNode_handle), POINTER :: fromParent_result
        END FUNCTION ! DATDcHitsNode_from_DATColiasNod

! Attribute Accessors

            FUNCTION DATDcHitsNode_nHits( handle ) &
                RESULT ( nHits_result )
                USE DATDcHitsNode_handler
                USE DATDcHit_handler
                INTEGER :: nHits_result
                TYPE(DATDcHitsNode_handle), INTENT(IN) :: handle
            END FUNCTION ! DATDcHitsNode_nHits

! Operations

            FUNCTION DATDcHitsNode_hit( handle, index ) &
                RESULT ( hit_result )
                USE DATDcHitsNode_handler
                USE DATDcHit_handler
                TYPE(DATDcHit_handle), POINTER :: hit_result
                TYPE(DATDcHitsNode_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: index
            END FUNCTION ! DATDcHitsNode_hit

        END INTERFACE

    END MODULE ! DATDcHitsNode_interface

    MODULE DATDcHitsNode_data

        TYPE DATDcHitsNode
            INTEGER :: nHits
        END TYPE DATDcHitsNode

        CONTAINS

            SUBROUTINE DATDcHitsNode_toF90( src, dst )
                USE DATDcHitsNode_interface
                USE DATDcHitsNode_handler
                USE DATDcHit_handler
                IMPLICIT NONE
                TYPE(DATDcHitsNode_handle), POINTER :: src
                TYPE(DATDcHitsNode) :: dst
                dst % nHits = DATDcHitsNode_nHits( src )
                RETURN
            END SUBROUTINE ! DATDcHitsNode_toF90

    END MODULE ! DATDcHitsNode_data

    MODULE DATDcHitsNode_module

        USE DATDcHitsNode_handler
        USE DATDcHitsNode_interface
        USE DATDcHitsNode_data

    END MODULE ! DATDcHitsNode_module

    MODULE DATSVTCluster_handler

        TYPE DATSVTCluster_handle
            PRIVATE
            INTEGER :: dummy ! Dummy to satisfy compiler
        END TYPE DATSVTCluster_handle

    END MODULE ! DATSVTCluster_handler

    MODULE DATSVTCluster_interface

        INTERFACE

! Constructor & Destructor

            FUNCTION DATSVTCluster_new( ) &
                RESULT ( new_result )
                USE DATSVTCluster_handler
                TYPE(DATSVTCluster_handle), POINTER :: new_result
            END FUNCTION ! DATSVTCluster_new
            SUBROUTINE DATSVTCluster_delete( handle )
                USE DATSVTCluster_handler
                TYPE(DATSVTCluster_handle), POINTER :: handle
            END SUBROUTINE ! DATSVTCluster_delete

! Attribute Accessors

            FUNCTION DATSVTCluster_layer( handle ) &
                RESULT ( layer_result )
                USE DATSVTCluster_handler
                INTEGER :: layer_result
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
            END FUNCTION ! DATSVTCluster_layer
            FUNCTION DATSVTCluster_readoutSection( handle ) &
                RESULT ( readoutSection_result )
                USE DATSVTCluster_handler
                INTEGER :: readoutSection_result
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
            END FUNCTION ! DATSVTCluster_readoutSection
            FUNCTION DATSVTCluster_wafer( handle ) &
                RESULT ( wafer_result )
                USE DATSVTCluster_handler
                INTEGER :: wafer_result
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
            END FUNCTION ! DATSVTCluster_wafer
            FUNCTION DATSVTCluster_flag( handle ) &
                RESULT ( flag_result )
                USE DATSVTCluster_handler
                INTEGER :: flag_result
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
            END FUNCTION ! DATSVTCluster_flag
            FUNCTION DATSVTCluster_gangGroup( handle ) &
                RESULT ( gangGroup_result )
                USE DATSVTCluster_handler
                INTEGER :: gangGroup_result
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
            END FUNCTION ! DATSVTCluster_gangGroup
            FUNCTION DATSVTCluster_width( handle ) &
                RESULT ( width_result )
                USE DATSVTCluster_handler
                INTEGER :: width_result
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
            END FUNCTION ! DATSVTCluster_width
            FUNCTION DATSVTCluster_afterGap( handle ) &
                RESULT ( afterGap_result )
                USE DATSVTCluster_handler
                INTEGER :: afterGap_result
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
            END FUNCTION ! DATSVTCluster_afterGap
            FUNCTION DATSVTCluster_beforeGap( handle ) &
                RESULT ( beforeGap_result )
                USE DATSVTCluster_handler
                INTEGER :: beforeGap_result
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
            END FUNCTION ! DATSVTCluster_beforeGap
            FUNCTION DATSVTCluster_time( handle ) &
                RESULT ( time_result )
                USE DATSVTCluster_handler
                REAL :: time_result
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
            END FUNCTION ! DATSVTCluster_time
            FUNCTION DATSVTCluster_position( handle ) &
                RESULT ( position_result )
                USE DATSVTCluster_handler
                REAL :: position_result
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
            END FUNCTION ! DATSVTCluster_position
            FUNCTION DATSVTCluster_pulseHeight( handle ) &
                RESULT ( pulseHeight_result )
                USE DATSVTCluster_handler
                REAL :: pulseHeight_result
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
            END FUNCTION ! DATSVTCluster_pulseHeight

! Attribute Modifiers

            SUBROUTINE DATSVTCluster_setLayer( handle, layer )
                USE DATSVTCluster_handler
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: layer
            END SUBROUTINE ! DATSVTCluster_setLayer
            SUBROUTINE DATSVTCluster_setReadoutSection( handle,  
readoutSection )
                USE DATSVTCluster_handler
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: readoutSection
            END SUBROUTINE ! DATSVTCluster_setReadoutSection
            SUBROUTINE DATSVTCluster_setWafer( handle, wafer )
                USE DATSVTCluster_handler
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: wafer
            END SUBROUTINE ! DATSVTCluster_setWafer
            SUBROUTINE DATSVTCluster_setFlag( handle, flag )
                USE DATSVTCluster_handler
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: flag
            END SUBROUTINE ! DATSVTCluster_setFlag
            SUBROUTINE DATSVTCluster_setGangGroup( handle, gangGroup )
                USE DATSVTCluster_handler
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: gangGroup
            END SUBROUTINE ! DATSVTCluster_setGangGroup
            SUBROUTINE DATSVTCluster_setWidth( handle, width )
                USE DATSVTCluster_handler
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: width
            END SUBROUTINE ! DATSVTCluster_setWidth
            SUBROUTINE DATSVTCluster_setAfterGap( handle, afterGap )
                USE DATSVTCluster_handler
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: afterGap
            END SUBROUTINE ! DATSVTCluster_setAfterGap
            SUBROUTINE DATSVTCluster_setBeforeGap( handle, beforeGap )
                USE DATSVTCluster_handler
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: beforeGap
            END SUBROUTINE ! DATSVTCluster_setBeforeGap
            SUBROUTINE DATSVTCluster_setTime( handle, time )
                USE DATSVTCluster_handler
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
                REAL, INTENT(IN) :: time
            END SUBROUTINE ! DATSVTCluster_setTime
            SUBROUTINE DATSVTCluster_setPosition( handle, position )
                USE DATSVTCluster_handler
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
                REAL, INTENT(IN) :: position
            END SUBROUTINE ! DATSVTCluster_setPosition
            SUBROUTINE DATSVTCluster_setPulseHeight( handle,  
pulseHeight )
                USE DATSVTCluster_handler
                TYPE(DATSVTCluster_handle), INTENT(IN) :: handle
                REAL, INTENT(IN) :: pulseHeight
            END SUBROUTINE ! DATSVTCluster_setPulseHeight

        END INTERFACE

    END MODULE ! DATSVTCluster_interface

    MODULE DATSVTCluster_data

        TYPE DATSVTCluster
            INTEGER :: layer
            INTEGER :: readoutSection
            INTEGER :: wafer
            INTEGER :: flag
            INTEGER :: gangGroup
            INTEGER :: width
            INTEGER :: afterGap
            INTEGER :: beforeGap
            REAL :: time
            REAL :: position
            REAL :: pulseHeight
        END TYPE DATSVTCluster

        CONTAINS

            SUBROUTINE DATSVTCluster_toF90( src, dst )
                USE DATSVTCluster_interface
                USE DATSVTCluster_handler
                IMPLICIT NONE
                TYPE(DATSVTCluster_handle), POINTER :: src
                TYPE(DATSVTCluster) :: dst
                dst % layer          = DATSVTCluster_layer          
( src )
                dst % readoutSection =  
DATSVTCluster_readoutSection( src )
                dst % wafer          = DATSVTCluster_wafer          
( src )
                dst % flag           = DATSVTCluster_flag           
( src )
                dst % gangGroup      = DATSVTCluster_gangGroup      
( src )
                dst % width          = DATSVTCluster_width          
( src )
                dst % afterGap       = DATSVTCluster_afterGap       
( src )
                dst % beforeGap      = DATSVTCluster_beforeGap      
( src )
                dst % time           = DATSVTCluster_time           
( src )
                dst % position       = DATSVTCluster_position       
( src )
                dst % pulseHeight    = DATSVTCluster_pulseHeight    
( src )
                RETURN
            END SUBROUTINE ! DATSVTCluster_toF90

            SUBROUTINE DATSVTCluster_fromF90( src, dst )
                USE DATSVTCluster_interface
                USE DATSVTCluster_handler
                IMPLICIT NONE
                TYPE(DATSVTCluster) :: src
                TYPE(DATSVTCluster_handle), POINTER :: dst
                CALL DATSVTCluster_setLayer         ( dst, src %  
layer          )
                CALL DATSVTCluster_setReadoutSection( dst, src %  
readoutSection )
                CALL DATSVTCluster_setWafer         ( dst, src %  
wafer          )
                CALL DATSVTCluster_setFlag          ( dst, src %  
flag           )
                CALL DATSVTCluster_setGangGroup     ( dst, src %  
gangGroup      )
                CALL DATSVTCluster_setWidth         ( dst, src %  
width          )
                CALL DATSVTCluster_setAfterGap      ( dst, src %  
afterGap       )
                CALL DATSVTCluster_setBeforeGap     ( dst, src %  
beforeGap      )
                CALL DATSVTCluster_setTime          ( dst, src %  
time           )
                CALL DATSVTCluster_setPosition      ( dst, src %  
position       )
                CALL DATSVTCluster_setPulseHeight   ( dst, src %  
pulseHeight    )
                RETURN
            END SUBROUTINE ! DATSVTCluster_fromF90

    END MODULE ! DATSVTCluster_data

    MODULE DATSVTCluster_module

        USE DATSVTCluster_handler
        USE DATSVTCluster_interface
        USE DATSVTCluster_data

    END MODULE ! DATSVTCluster_module

    MODULE DATSVTClusterNode_handler

        CHARACTER (LEN=*), PARAMETER :: DATSVTClusterNode_type = "SVTC"

        TYPE DATSVTClusterNode_handle
            PRIVATE
            INTEGER :: dummy ! Dummy to satisfy compiler
        END TYPE DATSVTClusterNode_handle

    END MODULE ! DATSVTClusterNode_handler

    MODULE DATSVTClusterNode_interface

        INTERFACE

! Constructor & Destructor

            FUNCTION DATSVTClusterNode_new( ) &
                RESULT ( new_result )
                USE DATSVTClusterNode_handler
                USE DATSVTCluster_handler
                TYPE(DATSVTClusterNode_handle), POINTER :: new_result
            END FUNCTION ! DATSVTClusterNode_new
            SUBROUTINE DATSVTClusterNode_delete( handle )
                USE DATSVTClusterNode_handler
                USE DATSVTCluster_handler
                TYPE(DATSVTClusterNode_handle), POINTER :: handle
            END SUBROUTINE ! DATSVTClusterNode_delete

! Type casting from parent(s)

        FUNCTION DATSVTClusterNode_from_F_Node( handle ) &
            RESULT ( fromParent_result )
            USE F_Node_handler
            USE DATSVTClusterNode_handler
            TYPE(F_Node_handle), INTENT(IN) :: handle
            TYPE(DATSVTClusterNode_handle), POINTER :: fromParent_result
        END FUNCTION ! DATSVTClusterNode_from_F_Node
        FUNCTION DATSVTClusterNode_from_DATColia( handle ) &
            RESULT ( fromParent_result )
            USE DATColiasNode_handler
            USE DATSVTClusterNode_handler
            TYPE(DATColiasNode_handle), INTENT(IN) :: handle
            TYPE(DATSVTClusterNode_handle), POINTER :: fromParent_result
        END FUNCTION ! DATSVTClusterNode_from_DATColia

! Attribute Accessors

            FUNCTION DATSVTClusterNode_nClusters( handle ) &
                RESULT ( nClusters_result )
                USE DATSVTClusterNode_handler
                USE DATSVTCluster_handler
                INTEGER :: nClusters_result
                TYPE(DATSVTClusterNode_handle), INTENT(IN) :: handle
            END FUNCTION ! DATSVTClusterNode_nClusters

! Operations

            FUNCTION DATSVTClusterNode_cluster( handle, index ) &
                RESULT ( cluster_result )
                USE DATSVTClusterNode_handler
                USE DATSVTCluster_handler
                TYPE(DATSVTCluster_handle), POINTER :: cluster_result
                TYPE(DATSVTClusterNode_handle), INTENT(IN) :: handle
                INTEGER, INTENT(IN) :: index
            END FUNCTION ! DATSVTClusterNode_cluster

        END INTERFACE

    END MODULE ! DATSVTClusterNode_interface

    MODULE DATSVTClusterNode_data

        TYPE DATSVTClusterNode
            INTEGER :: nClusters
        END TYPE DATSVTClusterNode

        CONTAINS

            SUBROUTINE DATSVTClusterNode_toF90( src, dst )
                USE DATSVTClusterNode_interface
                USE DATSVTClusterNode_handler
                USE DATSVTCluster_handler
                IMPLICIT NONE
                TYPE(DATSVTClusterNode_handle), POINTER :: src
                TYPE(DATSVTClusterNode) :: dst
                dst % nClusters = DATSVTClusterNode_nClusters( src )
                RETURN
            END SUBROUTINE ! DATSVTClusterNode_toF90

    END MODULE ! DATSVTClusterNode_data

    MODULE DATSVTClusterNode_module

        USE DATSVTClusterNode_handler
        USE DATSVTClusterNode_interface
        USE DATSVTClusterNode_data

    END MODULE ! DATSVTClusterNode_module

    MODULE colias_module

        USE F_Node_module
        USE DATColiasNode_module
        USE DATEventNode_module
        USE DATFileNode_module
        USE DATHitsNode_module
        USE DATSimNode_module
        USE DATRawDataNode_module
        USE DATEMCDigi_module
        USE DATEMCRawNode_module
        USE DATSVTDigi_module
        USE DATSVTRawNode_module
        USE DATDcHit_module
        USE DATDcHitsNode_module
        USE DATSVTCluster_module
        USE DATSVTClusterNode_module

    END MODULE ! colias_module