PinCell.hxx

Go to the documentation of this file.

/*
  This file is part of MURE,
  Copyright (C) 2007-2021 MURE developers.
 
  MURE is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  MURE is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public License
  along with MURE.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef _PIN_HXX_
#define _PIN_HXX_
 
#include <algorithm>
#include <string>
#include <vector>
 
#include "Cell.hxx"
 
class Material;
 
 
class PinCell : public Cell
{
  public :
    PinCell(int universe = 0);
    PinCell(const PinCell &c);
    ~PinCell() override;
    PinCell *Clone() override
    {
        return new PinCell(*this);
    }
    PinCell *Duplicate();
 
 
 
    void AddLayer(Material *mat, double R, double Volume = - 1);
    Material *GetLayerMaterial(int i); 
    void SetLayerMaterial(int i, Material *mat)
    {
        fMaterialVector[i] = mat;   
    }
    double GetLayerRadius(int i); 
    int GetNumberOfLayer()
    {
        return fR.size();
    }; 
 
    void SetSurroundingMaterial(Material *mat, double Volume = - 1);
    Material *GetSurroundingMaterial() const
    {
        return fSurroundingMaterial;   
    }
    bool IsSurroundingMaterialCalled()
    {
        return fIsSurroundingMaterialCalled;   
    }
 
    void Translate(double dx, double dy, double dz, bool ForceTranslation = false);
    vector < double >  &GetTranslation()
    {
        return fTranslation;   
    }
    bool IsTrueTranslation()
    {
        return fTrueTranslation;   
    }
    bool IsTranslated(); 
 
    void SetLayerVolume(int i, double V)
    {
        fLayerVolume[i] = V;
    }
    double GetLayerVolume(int i)
    {
        return fLayerVolume[i];   
    }
 
    void AddSpatialVariable(int layeridx, string name, double value); 
    vector < string > &GetSpatialVariableNames(int layeridx)
    {
        return fPCSpatialVariableNames[layeridx];   
    }
    vector < double > &GetSpatialVariables(int layeridx)
    {
        return fPCSpatialVariables[layeridx];   
    }
    int GetUniverse() override
    {
        return fUniverse;   
    }
    void SetUniverse(int u)
    {
        fUniverse = u;   
    }
    void AddAssociatedCellNumber(int num)
    {
        fAssociatedCellNumber.push_back(num);
    }
    vector < int > &GetAssociatedCellNumber()
    {
        return fAssociatedCellNumber;   
    }
    Cell *GetAssociatedCell(int i); 
 
    void SetAutoBuildingCells(bool flag)
    {
        fAutoBuildingCells = flag;   
    }
    bool IsAutoBuildingCells()
    {
        return fAutoBuildingCells;   
    }
    void SetPinType(string type)
    {
        fPinType = type;   
    }
    string GetPinType()
    {
        return fPinType;   
    }
 
 
    void SetControlLayerNumber(int ControlLayerNumber)
    {
        fControlLayerNumber = ControlLayerNumber;   
    }
    int GetControlLayerNumber()
    {
        return fControlLayerNumber;   
    }
 
 
  private:
 
    vector  < double > fR;  
    vector  < double > fLayerVolume;        
    vector  < Material * > fMaterialVector; 
    Material *fSurroundingMaterial; 
 
    int fUniverse; 
    int fControlLayerNumber;
    bool fIsSurroundingMaterialCalled;
 
    vector  < int > fAssociatedCellNumber;
 
    bool    fAutoBuildingCells;
    vector  < double > fTranslation;
    bool    fTrueTranslation;
 
    vector  < vector < double > > fPCSpatialVariables;      
    vector  < vector < string > > fPCSpatialVariableNames;  
    string  fPinType;   
};
 
#endif