Cooldt Code

/*
 * Cooldt cool-down time calculator for multi-layers pipe
 *
 * Copyright 2010, 2013, 2014, Benjamin DEGLO DE BESSES. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are
 * permitted provided that the following conditions are met:
 *
 *    1. Redistributions of source code must retain the above copyright notice, this list of
 *       conditions and the following disclaimer.
 *
 *    2. Redistributions in binary form must reproduce the above copyright notice, this list
 *       of conditions and the following disclaimer in the documentation and/or other materials
 *       provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY Benjamin DEGLO DE BESSES "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Benjamin DEGLO DE BESSES OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include "cooldt.h"

/*
 * Allocate memory for the PZ structure base on size PZ->N
 */
void Size0PipeDiscretize(PipeDicretize *PZ)
{
    PZ->N = 0 ;

    PZ->L   = (int*)malloc(sizeof(int)) ;

    PZ->rc  = (double*)malloc(sizeof(double));
    PZ->rm  = (double*)malloc(sizeof(double));
    PZ->rp  = (double*)malloc(sizeof(double));

    PZ->S  = (double*)malloc(sizeof(double));

    PZ->kc  = (double*)malloc(sizeof(double));
    PZ->km  = (double*)malloc(sizeof(double));
    PZ->kp  = (double*)malloc(sizeof(double));

    PZ->d   = (double*)malloc(sizeof(double));
    PZ->Cp  = (double*)malloc(sizeof(double));

    PZ->alpha = (double*)malloc(sizeof(double));
    PZ->beta  = (double*)malloc(sizeof(double));
    PZ->gamma  = (double*)malloc(sizeof(double));
}

/*
 * Increment size of the  PZ structure
 */
void IncrementSizePipeDiscretize(PipeDicretize *PZ)
{
    PZ->N++ ;
    size_t DoublesSize = (PZ->N + 1) * sizeof(double) ;

    PZ->L   = (int*)realloc(PZ->L, (PZ->N + 1) * sizeof(int) );

    PZ->rc  = (double*)realloc(PZ->rc,  DoublesSize);
    PZ->rm  = (double*)realloc(PZ->rm,  DoublesSize);
    PZ->rp  = (double*)realloc(PZ->rp,  DoublesSize);

    PZ->S  =  (double*)realloc(PZ->S,   DoublesSize);

    PZ->kc  = (double*)realloc(PZ->kc,  DoublesSize);
    PZ->km  = (double*)realloc(PZ->km,  DoublesSize);
    PZ->kp  = (double*)realloc(PZ->kp,  DoublesSize);

    PZ->Cp  = (double*)realloc(PZ->Cp,  DoublesSize);
    PZ->d   = (double*)realloc(PZ->d,   DoublesSize);

    PZ->alpha = (double*)realloc(PZ->alpha, DoublesSize);
    PZ->beta  = (double*)realloc(PZ->beta,  DoublesSize);
    PZ->gamma = (double*)realloc(PZ->gamma, DoublesSize);

}

/*
 * Free memory for PZ structures dynamics elements (AKA pointers)
 */
void FreePipeDiscretize(PipeDicretize *PZ)
{
    free(PZ->L)   ;

    free(PZ->rc)  ;
    free(PZ->rm)  ;
    free(PZ->rp)  ;

    free(PZ->S)   ;

    free(PZ->kc)  ;
    free(PZ->km)  ;
    free(PZ->kp)  ;

    free(PZ->Cp)  ;
    free(PZ->d)   ;

    free(PZ->alpha)  ;
    free(PZ->beta)   ;
    free(PZ->gamma)  ;
}

/*
 * Allocate memory for the PP structure base on size PP->N
 */
void SizePipeProblem(PipeProblem *PP)
{
    size_t DoublesSize = (PP->N + 1) * sizeof(double) ;

    PP->NbCell = (int*)malloc((PP->N + 1) * sizeof(int)) ;
    PP->k  = (double*)malloc(DoublesSize) ;
    PP->Cp = (double*)malloc(DoublesSize) ;
    PP->d  = (double*)malloc(DoublesSize) ;
    PP->r  = (double*)malloc(DoublesSize) ;
}

/*
 * Free memory for PP structures dynamics elements (AKA pointers)
 */
void FreePipeProblem(PipeProblem *PP)
{
    free(PP->NbCell) ;
    free(PP->k)  ;
    free(PP->Cp) ;
    free(PP->d)  ;
    free(PP->r)  ;
}

/*
 * Allocate memory for the Tot structure base on size Tot->n
 */
void Size0TfluidSolid(TfluidSolid *Tot)
{
    Tot->n = 0 ;
    Tot->tn = (double*)malloc(sizeof(double)) ;
    Tot->T  = (double*)malloc(sizeof(double)) ;
}

/*
 * Increment Size for the structure base
 */
void IncrementSizeTfluidSolid(TfluidSolid *Tot)
{
    Tot->n++ ;
    size_t DoublesSize = (Tot->n + 1) * sizeof(double) ;

    Tot->tn = (double*)realloc(Tot->tn, DoublesSize) ;
    Tot->T  = (double*)realloc(Tot->T,  DoublesSize) ;
}

/*
 * Free memory for Tot structures dynamics elements (AKA pointers)
 */
void FreeTfluidSolid(TfluidSolid *TfS)
{
    free(TfS->tn)  ;
    free(TfS->T) ;
}
/* End of alloc.c  */