/**
* @brief Gets the resistance items as a float array
*
* Get the current array of resistance values as float. This function converts to float on the fly from a char pointer array.
* @return float*
**/
static float* getResistanceItems(){
float* resistance = malloc(getNumberOfComponents()*sizeof(float));
int i = 0;
while(i < getNumberOfComponents()){
resistance[i] = atof(_resistanceValueList[i]);
printDebugText("Value converted from: %s to: %f", _resistanceValueList[i], resistance[i]);
i = i + 1;
}
return resistance;
}
void Mapping::calculateNumericalDerivatives( ActionWithValue* a ){
if( getNumberOfAtoms()>0 ){
ActionWithArguments::calculateNumericalDerivatives( a );
}
if( getNumberOfAtoms()>0 ){
Matrix<double> save_derivatives( getNumberOfComponents(), getNumberOfArguments() );
for(unsigned j=0;j<getNumberOfComponents();++j){
for(unsigned i=0;i<getNumberOfArguments();++i) save_derivatives(j,i)=getPntrToComponent(j)->getDerivative(i);
}
calculateAtomicNumericalDerivatives( a, getNumberOfArguments() );
for(unsigned j=0;j<getNumberOfComponents();++j){
for(unsigned i=0;i<getNumberOfArguments();++i) getPntrToComponent(j)->addDerivative( i, save_derivatives(j,i) );
}
}
}
void Function::apply()
{
const unsigned noa=getNumberOfArguments();
const unsigned ncp=getNumberOfComponents();
const unsigned cgs=comm.Get_size();
vector<double> f(noa,0.0);
unsigned stride=1;
unsigned rank=0;
if(ncp>4*cgs) {
stride=comm.Get_size();
rank=comm.Get_rank();
}
unsigned at_least_one_forced=0;
#pragma omp parallel num_threads(OpenMP::getNumThreads()) shared(f)
{
vector<double> omp_f(noa,0.0);
vector<double> forces(noa);
#pragma omp for reduction( + : at_least_one_forced)
for(unsigned i=rank; i<ncp; i+=stride) {
if(getPntrToComponent(i)->applyForce(forces)) {
at_least_one_forced+=1;
for(unsigned j=0; j<noa; j++) omp_f[j]+=forces[j];
}
}
#pragma omp critical
for(unsigned j=0; j<noa; j++) f[j]+=omp_f[j];
}
if(noa>0&&ncp>4*cgs) { comm.Sum(&f[0],noa); comm.Sum(at_least_one_forced); }
if(at_least_one_forced>0) for(unsigned i=0; i<noa; ++i) getPntrToArgument(i)->addForce(f[i]);
}
float* DataVar::getDataFlat() const
{
int totalSize = numSamples * getNumberOfComponents();
float* res = new float[totalSize];
if (rank == 0) {
copy(dataArray[0], dataArray[0]+numSamples, res);
} else if (rank == 1) {
float *dest = res;
for (size_t c=0; c<numSamples; c++) {
for (size_t i=0; i<shape[0]; i++) {
*dest++ = dataArray[i][c];
}
}
} else if (rank == 2) {
float *dest = res;
for (size_t c=0; c<numSamples; c++) {
for (int i=0; i<shape[1]; i++) {
for (int j=0; j<shape[0]; j++) {
*dest++ = dataArray[i*shape[0]+j][c];
}
}
}
}
return res;
}
void Bias::apply() {
const unsigned noa=getNumberOfArguments();
const unsigned ncp=getNumberOfComponents();
if(onStep()) {
double gstr = static_cast<double>(getStride());
for(unsigned i=0; i<noa; ++i) {
getPntrToArgument(i)->addForce(gstr*outputForces[i]);
}
}
// additional forces on the bias component
std::vector<double> f(noa,0.0);
std::vector<double> forces(noa);
bool at_least_one_forced=false;
for(unsigned i=0; i<ncp; ++i) {
if(getPntrToComponent(i)->applyForce(forces)) {
at_least_one_forced=true;
for(unsigned j=0; j<noa; j++) f[j]+=forces[j];
}
}
if(at_least_one_forced && !onStep()) error("you are biasing a bias with an inconsistent STRIDE");
if(at_least_one_forced) for(unsigned i=0; i<noa; ++i) {
getPntrToArgument(i)->addForce(f[i]);
}
}
std::unique_ptr<LocalToGlobalIndexMap>
LocalToGlobalIndexMap::deriveBoundaryConstrainedMap(
MeshLib::MeshSubset&& new_mesh_subset) const
{
DBUG("Construct reduced local to global index map.");
// Create a subset of the current mesh component map.
std::vector<int> global_component_ids;
for (int i = 0; i < getNumberOfComponents(); ++i)
{
global_component_ids.push_back(i);
}
// Elements of the new_mesh_subset's mesh.
std::vector<MeshLib::Element*> const& elements =
new_mesh_subset.getMesh().getElements();
auto mesh_component_map = _mesh_component_map.getSubset(
_mesh_subsets, new_mesh_subset, global_component_ids);
// Create copies of the new_mesh_subset for each of the global components.
// The last component is moved after the for-loop.
std::vector<MeshLib::MeshSubset> all_mesh_subsets;
for (int i = 0; i < static_cast<int>(global_component_ids.size()) - 1; ++i)
all_mesh_subsets.emplace_back(new_mesh_subset);
all_mesh_subsets.emplace_back(std::move(new_mesh_subset));
return std::make_unique<LocalToGlobalIndexMap>(
std::move(all_mesh_subsets), global_component_ids,
_variable_component_offsets, elements, std::move(mesh_component_map),
ConstructorTag{});
}
void Colvar::requestAtoms(const vector<AtomNumber> & a){
plumed_massert(!isEnergy,"request atoms should not be called if this is energy");
// Tell actionAtomistic what atoms we are getting
ActionAtomistic::requestAtoms(a);
// Resize the derivatives of all atoms
for(int i=0;i<getNumberOfComponents();++i) getPntrToComponent(i)->resizeDerivatives(3*a.size()+9);
}
void Sprint::apply() {
std::vector<Vector>& f(modifyForces());
Tensor& v(modifyVirial());
unsigned nat=getNumberOfAtoms();
std::vector<double> forces( 3*getNumberOfAtoms() + 9 );
for(int i=0; i<getNumberOfComponents(); ++i) {
if( getPntrToComponent(i)->applyForce( forces ) ) {
for(unsigned j=0; j<nat; ++j) {
f[j][0]+=forces[3*j+0];
f[j][1]+=forces[3*j+1];
f[j][2]+=forces[3*j+2];
}
v(0,0)+=forces[3*nat+0];
v(0,1)+=forces[3*nat+1];
v(0,2)+=forces[3*nat+2];
v(1,0)+=forces[3*nat+3];
v(1,1)+=forces[3*nat+4];
v(1,2)+=forces[3*nat+5];
v(2,0)+=forces[3*nat+6];
v(2,1)+=forces[3*nat+7];
v(2,2)+=forces[3*nat+8];
}
}
}
/**
* @brief Sets the number of components
*
* Sets the number of components
* @param value The number of components
* @return void
**/
static void setNumberOfComponents(char* value){
int oldNumberOfComponents = getNumberOfComponents();
_numberOfComponents = value;
printDebugText("Number of components before change: %d, after: %s", oldNumberOfComponents, value);
int i = 0;
printDebugText("All values before changing the number of components:");
if(_resistanceValueList == NULL)
printDebugText("Resistance is null");
while(i < oldNumberOfComponents){
printDebugText("Checking positions..");
printDebugText("Position: %d had %s \n", i, _resistanceValueList[i]);
i = i + 1;
}
printDebugText("MainGrid address %p", _mainGrid);
initResistanceListSection(getNumberOfComponents(), oldNumberOfComponents, &_resistanceValueList, _mainGrid, resistanceListItemChanged);
}
virtual IDataArray::Pointer reorderCopy(QVector<size_t> newOrderMap)
{
if(newOrderMap.size() != static_cast<QVector<size_t>::size_type>(getNumberOfTuples()))
{
return IDataArray::NullPointer();
}
IDataArray::Pointer daCopy = createNewArray(getNumberOfTuples(), getComponentDimensions(), getName(), m_IsAllocated);
if(m_IsAllocated == true)
{
daCopy->initializeWithZeros();
size_t chunkSize = getNumberOfComponents() * sizeof(T);
for(size_t i = 0; i < getNumberOfTuples(); i++)
{
T* src = getPointer(i * getNumberOfComponents());
void* dest = daCopy->getVoidPointer(newOrderMap[i] * getNumberOfComponents());
::memcpy(dest, src, chunkSize);
}
}
return daCopy;
}
/**
* @brief deepCopy
* @param forceNoAllocate
* @return
*/
virtual IDataArray::Pointer deepCopy(bool forceNoAllocate = false)
{
IDataArray::Pointer daCopy = createNewArray(getNumberOfTuples(), getComponentDimensions(), getName(), m_IsAllocated);
if(m_IsAllocated == true && forceNoAllocate == false)
{
T* src = getPointer(0);
void* dest = daCopy->getVoidPointer(0);
size_t totalBytes = (getNumberOfTuples() * getNumberOfComponents() * sizeof(T));
::memcpy(dest, src, totalBytes);
}
return daCopy;
}
/**
* @brief copyData This method copies all data from the <b>sourceArray</b> into
* the current array starting at the target destination tuple offset value.
*
* For example if the DataArray has 10 tuples and the destTupleOffset = 5 then
* then source data will be copied into the destination array starting at
* destination tuple 5. In psuedo code it would be the following:
* @code
* destArray[5] = sourceArray[0];
* destArray[6] = sourceArray[1];
* .....
* @endcode
* @param destTupleOffset
* @param sourceArray
* @return
*/
bool copyData(size_t destTupleOffset, IDataArray::Pointer sourceArray)
{
if(destTupleOffset >= m_Array.size()) { return false; }
if(!sourceArray->isAllocated()) { return false; }
if(sourceArray->getNumberOfComponents() != getNumberOfComponents()) { return false; }
Self* source = dynamic_cast<Self*>(sourceArray.get());
size_t sourceNTuples = source->getNumberOfTuples();
for(size_t i = 0; i < sourceNTuples; i++)
{
m_Array[destTupleOffset + i] = source->getValue(i);
}
return true;
}
/**
* @brief writeXdmfAttribute
* @param out
* @param volDims
* @return
*/
virtual int writeXdmfAttribute(QTextStream& out, int64_t* volDims, const QString& hdfFileName,
const QString& groupPath, const QString& label)
{
if (m_Array == NULL) { return -85648; }
QString dimStr;
int precision = 0;
QString xdmfTypeName;
getXdmfTypeAndSize(xdmfTypeName, precision);
if (0 == precision)
{
out << "<!-- " << getName() << " has unknown type or unsupported type or precision for XDMF to understand" << " -->" << "\n";
return -100;
}
int numComp = getNumberOfComponents();
out << " <Attribute Name=\"" << getName() << label << "\" ";
if (numComp == 1)
{
out << "AttributeType=\"Scalar\" ";
dimStr = QString("%1 %2 %3 ").arg(volDims[2]).arg(volDims[1]).arg(volDims[0]);
}
else if( numComp == 6)
{
out << "AttributeType=\"Tensor6\" ";
dimStr = QString("%1 %2 %3 %4 ").arg(volDims[2]).arg(volDims[1]).arg(volDims[0]).arg(numComp);
}
else if( numComp == 9)
{
out << "AttributeType=\"Tensor\" ";
dimStr = QString("%1 %2 %3 %4 ").arg(volDims[2]).arg(volDims[1]).arg(volDims[0]).arg(numComp);
}
else
{
out << "AttributeType=\"Vector\" ";
dimStr = QString("%1 %2 %3 %4 ").arg(volDims[2]).arg(volDims[1]).arg(volDims[0]).arg(numComp);
}
out << "Center=\"Cell\">\n" ;
// Open the <DataItem> Tag
out << " <DataItem Format=\"HDF\" Dimensions=\"" << dimStr << "\" ";
out << "NumberType=\"" << xdmfTypeName << "\" " << "Precision=\"" << precision << "\" >\n" ;
out << " " << hdfFileName << groupPath << "/" << getName() << "\n";
out << " </DataItem>" << "\n";
out << " </Attribute>" << "\n";
return 1;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RawBinaryReader::writeFilterParameters(AbstractFilterParametersWriter* writer)
{
/* Place code that will write the inputs values into a file. reference the
AbstractFilterParametersWriter class for the proper API to use. */
writer->writeValue("ScalarType", getScalarType() );
writer->writeValue("Dimensionality", getDimensionality() );
writer->writeValue("NumberOfComponents", getNumberOfComponents() );
writer->writeValue("Endian", getEndian() );
writer->writeValue("Dimensions", getDimensions() );
writer->writeValue("Origin", getOrigin() );
writer->writeValue("Resolution", getResolution() );
writer->writeValue("InputFile", getInputFile() );
writer->writeValue("OverRideOriginResolution", getOverRideOriginResolution() );
writer->writeValue("SkipHeaderBytes", getSkipHeaderBytes() );
writer->writeValue("OutputArrayName", getOutputArrayName() );
}
/**
* @brief Event method that is fired when it's time to calculate the output of the input
*
* Event method that fires when the button is clicked. This calculates the result of the electrolib functionality.
* @return void
**/
static void calculateAndPresentOutput(){
int RESISTANCEOUTPUTLABELROW = 6;
int VOLTAGEOUTPUTLABELROW = 7;
int E12OUTPUTLABELROW = 8;
float* replaceResistanceValues = calloc(3,sizeof(float));
float totalresistance = calc_resistance(getNumberOfComponents(), getConnectionType(), getResistanceItems());
float totalpower = calc_power_r(getVoltage(), totalresistance);
int numberOfResistors = e_resistance(totalresistance, replaceResistanceValues);
char formatedMessage[100];
sprintf(formatedMessage, "Ersättningsresistance: %.1f ohm", totalresistance);
addOutputLabel(_mainGrid, formatedMessage, 1, RESISTANCEOUTPUTLABELROW, 2);
sprintf(formatedMessage, "Effekt: %.2f W", totalpower);
addOutputLabel(_mainGrid, formatedMessage, 1, VOLTAGEOUTPUTLABELROW, 2);
sprintf(formatedMessage, "Ersättningsresistans i E12-serien koppliade i serie: %.0f, %.0f, %.0f", *replaceResistanceValues, *(replaceResistanceValues+1), *(replaceResistanceValues+2));
addOutputLabel(_mainGrid, formatedMessage, 1, E12OUTPUTLABELROW, 2);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RawBinaryReader::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
/* Code to read the values goes between these statements */
/* FILTER_WIDGETCODEGEN_AUTO_GENERATED_CODE BEGIN*/
setInputFile( reader->readValue( "InputFile", getInputFile() ) );
setScalarType( reader->readValue("ScalarType", getScalarType()) );
setDimensionality( reader->readValue("Dimensionality", getDimensionality()) );
setNumberOfComponents( reader->readValue("NumberOfComponents", getNumberOfComponents()) );
setEndian( reader->readValue("Endian", getEndian()) );
setDimensions( reader->readValue("Dimensions", getDimensions() ) );
setOrigin( reader->readValue("Origin", getOrigin() ) );
setResolution( reader->readValue("Resolution", getResolution() ) );
setOverRideOriginResolution( reader->readValue("OverRideOriginResolution", getOverRideOriginResolution()) );
setSkipHeaderBytes( reader->readValue("SkipHeaderBytes", getSkipHeaderBytes()) );
setOutputArrayName( reader->readValue( "OutputArrayName", getOutputArrayName() ) );
/* FILTER_WIDGETCODEGEN_AUTO_GENERATED_CODE END*/
reader->closeFilterGroup();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int RawBinaryReader::writeFilterParameters(AbstractFilterParametersWriter* writer, int index)
{
writer->openFilterGroup(this, index);
/* Place code that will write the inputs values into a file. reference the
AbstractFilterParametersWriter class for the proper API to use. */
writer->writeValue("ScalarType", getScalarType() );
writer->writeValue("Dimensionality", getDimensionality() );
writer->writeValue("NumberOfComponents", getNumberOfComponents() );
writer->writeValue("Endian", getEndian() );
writer->writeValue("Dimensions", getDimensions() );
writer->writeValue("Origin", getOrigin() );
writer->writeValue("Resolution", getResolution() );
writer->writeValue("InputFile", getInputFile() );
writer->writeValue("OverRideOriginResolution", getOverRideOriginResolution() );
writer->writeValue("SkipHeaderBytes", getSkipHeaderBytes() );
writer->writeValue("OutputArrayName", getOutputArrayName() );
writer->closeFilterGroup();
return ++index; // we want to return the next index that was just written to
}
/**
* @brief Starts the whole application and calls the electrolibui to present the UI in GTK
*
* Starts the whole application and calls the electrolibui to present the UI in GTK
* @return void
**/
int main(int argc, char *argv[]){
GtkWidget *calcButton;
GtkWidget *closeButton;
_mainGrid = createWindowAndMainGrid(argc, argv, destroy, delete_event);
addOutputLabel(_mainGrid, "Ange basdata: ", 1, 1, 1);
addInputSection("Ange spänningskälla i V: ",_mainGrid, voltageChanged, 1, 2,0);
addCheckbox("Räkna med Parallell koppling istället för Seriell",_mainGrid, connectionTypeChanged, 1, 3);
addDropDownList(10,_mainGrid, numberOfComponentsChanged, 1,4);
addOutputLabel(_mainGrid, "Komponenter och spänning: ", 2, 1, 1);
initResistanceListSection(getNumberOfComponents(),0, &_resistanceValueList, _mainGrid, resistanceListItemChanged);
addButton("Beräkna!", _mainGrid, calculateAndPresentOutput, 1, 5, 2);
addButton("Avsluta", _mainGrid, destroy, 1, 9, 2);
addButton("Test!", _mainGrid, runTestsEvent, 1, 10, 2);
gtk_main();
return 0;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
bool ModifiedLambertProjectionArray::copyData(size_t destTupleOffset, IDataArray::Pointer sourceArray)
{
if(!m_IsAllocated) { return false; }
if(0 == m_ModifiedLambertProjectionArray.size()) { return false; }
if(destTupleOffset >= m_ModifiedLambertProjectionArray.size()) { return false; }
if(!sourceArray->isAllocated()) { return false; }
Self* source = dynamic_cast<Self*>(sourceArray.get());
if(sourceArray->getNumberOfComponents() != getNumberOfComponents()) { return false; }
if( sourceArray->getNumberOfTuples()*sourceArray->getNumberOfComponents() + destTupleOffset*getNumberOfComponents() > m_ModifiedLambertProjectionArray.size() ) { return false; }
size_t sourceNTuples = source->getNumberOfTuples();
for(size_t i = 0; i < sourceNTuples; i++)
{
m_ModifiedLambertProjectionArray[destTupleOffset + i] = (*source)[i];
}
return true;
}
void Colvar::apply(){
vector<Vector>& f(modifyForces());
Tensor& v(modifyVirial());
unsigned nat=getNumberOfAtoms();
for(unsigned i=0;i<f.size();i++){
f[i][0]=0.0;
f[i][1]=0.0;
f[i][2]=0.0;
}
v.zero();
if(!isEnergy){
for(int i=0;i<getNumberOfComponents();++i){
if( getPntrToComponent(i)->applyForce( forces ) ){
for(unsigned j=0;j<nat;++j){
f[j][0]+=forces[3*j+0];
f[j][1]+=forces[3*j+1];
f[j][2]+=forces[3*j+2];
}
v(0,0)+=forces[3*nat+0];
v(0,1)+=forces[3*nat+1];
v(0,2)+=forces[3*nat+2];
v(1,0)+=forces[3*nat+3];
v(1,1)+=forces[3*nat+4];
v(1,2)+=forces[3*nat+5];
v(2,0)+=forces[3*nat+6];
v(2,1)+=forces[3*nat+7];
v(2,2)+=forces[3*nat+8];
}
}
} else if( isEnergy ){
forces.resize(1);
if( getPntrToComponent(0)->applyForce( forces ) ) modifyForceOnEnergy()+=forces[0];
}
}
//------------------------------------------------------------------------------
// getNumberOfSteerpoints() -- returns the number of components (stpts) in our
// list
//------------------------------------------------------------------------------
unsigned int Route::getNumberOfSteerpoints() const
{
return getNumberOfComponents();
}
void Colvar::apply(){
vector<Vector>& f(modifyForces());
Tensor& v(modifyVirial());
const unsigned nat=getNumberOfAtoms();
const unsigned ncp=getNumberOfComponents();
const unsigned fsz=f.size();
for(unsigned i=0;i<fsz;i++) f[i].zero();
v.zero();
unsigned stride=1;
unsigned rank=0;
if(ncp>comm.Get_size()) {
stride=comm.Get_size();
rank=comm.Get_rank();
}
unsigned nt=OpenMP::getNumThreads();
if(nt>ncp/(2.*stride)) nt=1;
if(!isEnergy){
#pragma omp parallel num_threads(nt)
{
vector<Vector> omp_f(fsz);
Tensor omp_v;
vector<double> forces(3*nat+9);
#pragma omp for
for(unsigned i=rank;i<ncp;i+=stride){
if(getPntrToComponent(i)->applyForce(forces)){
for(unsigned j=0;j<nat;++j){
omp_f[j][0]+=forces[3*j+0];
omp_f[j][1]+=forces[3*j+1];
omp_f[j][2]+=forces[3*j+2];
}
omp_v(0,0)+=forces[3*nat+0];
omp_v(0,1)+=forces[3*nat+1];
omp_v(0,2)+=forces[3*nat+2];
omp_v(1,0)+=forces[3*nat+3];
omp_v(1,1)+=forces[3*nat+4];
omp_v(1,2)+=forces[3*nat+5];
omp_v(2,0)+=forces[3*nat+6];
omp_v(2,1)+=forces[3*nat+7];
omp_v(2,2)+=forces[3*nat+8];
}
}
#pragma omp critical
{
for(unsigned j=0;j<nat;++j) f[j]+=omp_f[j];
v+=omp_v;
}
}
if(ncp>comm.Get_size()) {
if(fsz>0) comm.Sum(&f[0][0],3*fsz);
comm.Sum(&v[0][0],9);
}
} else if( isEnergy ){
vector<double> forces(1);
if(getPntrToComponent(0)->applyForce(forces)) modifyForceOnEnergy()+=forces[0];
}
}
TEST_F(InSituMesh, DISABLED_MappedMeshSourceRoundtrip)
#endif
{
// TODO Add more comparison criteria
ASSERT_TRUE(mesh != nullptr);
std::string test_data_file(BaseLib::BuildInfo::tests_tmp_path + "/MappedMeshSourceRoundtrip.vtu");
// -- Test VtkMappedMeshSource, i.e. OGS mesh to VTK mesh
vtkNew<MeshLib::VtkMappedMeshSource> vtkSource;
vtkSource->SetMesh(mesh);
vtkSource->Update();
vtkUnstructuredGrid* output = vtkSource->GetOutput();
// Point and cell numbers
ASSERT_EQ((subdivisions+1)*(subdivisions+1)*(subdivisions+1), output->GetNumberOfPoints());
ASSERT_EQ(subdivisions*subdivisions*subdivisions, output->GetNumberOfCells());
// Point data arrays
vtkDataArray* pointDoubleArray = output->GetPointData()->GetScalars("PointDoubleProperty");
ASSERT_EQ(pointDoubleArray->GetSize(), mesh->getNumberOfNodes());
ASSERT_EQ(pointDoubleArray->GetComponent(0, 0), 1.0);
double* range = pointDoubleArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], 1.0 + mesh->getNumberOfNodes() - 1.0);
vtkDataArray* pointIntArray = output->GetPointData()->GetScalars("PointIntProperty");
ASSERT_EQ(pointIntArray->GetSize(), mesh->getNumberOfNodes());
ASSERT_EQ(pointIntArray->GetComponent(0, 0), 1.0);
range = pointIntArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], 1 + mesh->getNumberOfNodes() - 1);
vtkDataArray* pointUnsignedArray = output->GetPointData()->GetScalars("PointUnsignedProperty");
ASSERT_EQ(pointUnsignedArray->GetSize(), mesh->getNumberOfNodes());
ASSERT_EQ(pointUnsignedArray->GetComponent(0, 0), 1.0);
range = pointUnsignedArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], 1 + mesh->getNumberOfNodes() - 1);
// Cell data arrays
vtkDataArray* cellDoubleArray = output->GetCellData()->GetScalars("CellDoubleProperty");
ASSERT_EQ(cellDoubleArray->GetSize(), mesh->getNumberOfElements());
ASSERT_EQ(cellDoubleArray->GetComponent(0, 0), 1.0);
range = cellDoubleArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], 1.0 + mesh->getNumberOfElements() - 1.0);
vtkDataArray* cellIntArray = output->GetCellData()->GetScalars("CellIntProperty");
ASSERT_EQ(cellIntArray->GetSize(), mesh->getNumberOfElements());
ASSERT_EQ(cellIntArray->GetComponent(0, 0), 1.0);
range = cellIntArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], 1 + mesh->getNumberOfElements() - 1);
vtkDataArray* cellUnsignedArray = output->GetCellData()->GetScalars("CellUnsignedProperty");
ASSERT_EQ(cellUnsignedArray->GetSize(), mesh->getNumberOfElements());
ASSERT_EQ(cellUnsignedArray->GetComponent(0, 0), 1.0);
range = cellUnsignedArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], 1 + mesh->getNumberOfElements() - 1);
// Field data arrays
vtkDataArray* fieldDoubleArray = vtkDataArray::SafeDownCast(
output->GetFieldData()->GetAbstractArray("FieldDoubleProperty"));
ASSERT_EQ(fieldDoubleArray->GetSize(), mesh->getNumberOfElements() * 2);
ASSERT_EQ(fieldDoubleArray->GetComponent(0, 0), 1.0);
range = fieldDoubleArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], mesh->getNumberOfElements() * 2);
vtkDataArray* fieldIntArray = vtkDataArray::SafeDownCast(
output->GetFieldData()->GetAbstractArray("FieldIntProperty"));
ASSERT_EQ(fieldIntArray->GetSize(), mesh->getNumberOfElements() * 2);
ASSERT_EQ(fieldIntArray->GetComponent(0, 0), 1.0);
range = fieldIntArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], mesh->getNumberOfElements() * 2);
vtkDataArray* fieldUnsignedArray = vtkDataArray::SafeDownCast(
output->GetFieldData()->GetAbstractArray("FieldUnsignedProperty"));
ASSERT_EQ(fieldUnsignedArray->GetSize(), mesh->getNumberOfElements() * 2);
ASSERT_EQ(fieldUnsignedArray->GetComponent(0, 0), 1.0);
range = fieldUnsignedArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], mesh->getNumberOfElements() * 2);
// -- Write VTK mesh to file (in all combinations of binary, appended and compressed)
// TODO: atm vtkXMLWriter::Ascii fails
for(int dataMode : { vtkXMLWriter::Appended, vtkXMLWriter::Binary })
{
for(bool compressed : { true, false })
{
if(dataMode == vtkXMLWriter::Ascii && compressed)
continue;
MeshLib::IO::VtuInterface vtuInterface(mesh, dataMode, compressed);
ASSERT_TRUE(vtuInterface.writeToFile(test_data_file));
// -- Read back VTK mesh
vtkSmartPointer<vtkXMLUnstructuredGridReader> reader =
vtkSmartPointer<vtkXMLUnstructuredGridReader>::New();
reader->SetFileName(test_data_file.c_str());
reader->Update();
vtkUnstructuredGrid *vtkMesh = reader->GetOutput();
// Both VTK meshes should be identical
ASSERT_EQ(vtkMesh->GetNumberOfPoints(), output->GetNumberOfPoints());
ASSERT_EQ(vtkMesh->GetNumberOfCells(), output->GetNumberOfCells());
ASSERT_EQ(vtkMesh->GetFieldData()->GetNumberOfArrays(), output->GetFieldData()->GetNumberOfArrays());
ASSERT_EQ(vtkMesh->GetPointData()->GetScalars("PointDoubleProperty")->GetNumberOfTuples(),
pointDoubleArray->GetNumberOfTuples());
ASSERT_EQ(vtkMesh->GetPointData()->GetScalars("PointIntProperty")->GetNumberOfTuples(),
pointIntArray->GetNumberOfTuples());
ASSERT_EQ(vtkMesh->GetPointData()->GetScalars("PointUnsignedProperty")->GetNumberOfTuples(),
pointUnsignedArray->GetNumberOfTuples());
ASSERT_EQ(vtkMesh->GetCellData()->GetScalars("CellDoubleProperty")->GetNumberOfTuples(),
cellDoubleArray->GetNumberOfTuples());
ASSERT_EQ(vtkMesh->GetCellData()->GetScalars("CellIntProperty")->GetNumberOfTuples(),
cellIntArray->GetNumberOfTuples());
ASSERT_EQ(vtkMesh->GetCellData()->GetScalars("CellUnsignedProperty")->GetNumberOfTuples(),
cellUnsignedArray->GetNumberOfTuples());
auto get_field_data =
[&vtkMesh](std::string const array_name) -> vtkDataArray* {
return vtkDataArray::SafeDownCast(
vtkMesh->GetFieldData()->GetAbstractArray(
array_name.c_str()));
};
ASSERT_EQ(
get_field_data("FieldDoubleProperty")->GetNumberOfTuples(),
fieldDoubleArray->GetNumberOfTuples());
ASSERT_EQ(get_field_data("FieldIntProperty")->GetNumberOfTuples(),
fieldIntArray->GetNumberOfTuples());
ASSERT_EQ(
get_field_data("FieldUnsignedProperty")->GetNumberOfTuples(),
fieldUnsignedArray->GetNumberOfTuples());
// Both OGS meshes should be identical
auto newMesh = std::unique_ptr<MeshLib::Mesh>{MeshLib::VtkMeshConverter::convertUnstructuredGrid(vtkMesh)};
ASSERT_EQ(mesh->getNumberOfNodes(), newMesh->getNumberOfNodes());
ASSERT_EQ(mesh->getNumberOfElements(), newMesh->getNumberOfElements());
// Both properties should be identical
auto meshProperties = mesh->getProperties();
auto newMeshProperties = newMesh->getProperties();
ASSERT_EQ(newMeshProperties.hasPropertyVector("PointDoubleProperty"),
meshProperties.hasPropertyVector("PointDoubleProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("PointIntProperty"),
meshProperties.hasPropertyVector("PointIntProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("PointUnsignedProperty"),
meshProperties.hasPropertyVector("PointUnsignedProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("CellDoubleProperty"),
meshProperties.hasPropertyVector("CellDoubleProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("CellIntProperty"),
meshProperties.hasPropertyVector("CellIntProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("CellUnsignedProperty"),
meshProperties.hasPropertyVector("CellUnsignedProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("FieldDoubleProperty"),
meshProperties.hasPropertyVector("FieldDoubleProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("FieldIntProperty"),
meshProperties.hasPropertyVector("FieldIntProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("FieldUnsignedProperty"),
meshProperties.hasPropertyVector("FieldUnsignedProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("MaterialIDs"),
meshProperties.hasPropertyVector("MaterialIDs"));
// Check some properties on equality
auto const* const doubleProps =
meshProperties.getPropertyVector<double>("PointDoubleProperty");
auto const* const newDoubleProps =
newMeshProperties.getPropertyVector<double>(
"PointDoubleProperty");
ASSERT_EQ(newDoubleProps->getNumberOfComponents(),
doubleProps->getNumberOfComponents());
ASSERT_EQ(newDoubleProps->getNumberOfTuples(),
doubleProps->getNumberOfTuples());
ASSERT_EQ(newDoubleProps->size(), doubleProps->size());
for (std::size_t i = 0; i < doubleProps->size(); i++)
ASSERT_EQ((*newDoubleProps)[i], (*doubleProps)[i]);
auto unsignedProps = meshProperties.getPropertyVector<unsigned>(
"CellUnsignedProperty");
auto newUnsignedIds = newMeshProperties.getPropertyVector<unsigned>(
"CellUnsignedProperty");
ASSERT_EQ(newUnsignedIds->getNumberOfComponents(),
unsignedProps->getNumberOfComponents());
ASSERT_EQ(newUnsignedIds->getNumberOfTuples(),
unsignedProps->getNumberOfTuples());
ASSERT_EQ(newUnsignedIds->size(), unsignedProps->size());
for (std::size_t i = 0; i < unsignedProps->size(); i++)
ASSERT_EQ((*newUnsignedIds)[i], (*unsignedProps)[i]);
{ // Field data
auto p =
meshProperties.getPropertyVector<int>("FieldIntProperty");
auto new_p = newMeshProperties.getPropertyVector<int>(
"FieldIntProperty");
ASSERT_EQ(new_p->getNumberOfComponents(),
p->getNumberOfComponents());
ASSERT_EQ(new_p->getNumberOfTuples(), p->getNumberOfTuples());
ASSERT_EQ(new_p->size(), p->size());
for (std::size_t i = 0; i < unsignedProps->size(); i++)
ASSERT_EQ((*newUnsignedIds)[i], (*unsignedProps)[i]);
}
auto const* const materialIds =
meshProperties.getPropertyVector<int>("MaterialIDs");
auto const* const newMaterialIds =
newMeshProperties.getPropertyVector<int>("MaterialIDs");
ASSERT_EQ(newMaterialIds->getNumberOfComponents(),
materialIds->getNumberOfComponents());
ASSERT_EQ(newMaterialIds->getNumberOfTuples(),
materialIds->getNumberOfTuples());
ASSERT_EQ(newMaterialIds->size(), materialIds->size());
for (std::size_t i = 0; i < materialIds->size(); i++)
ASSERT_EQ((*newMaterialIds)[i], (*materialIds)[i]);
}
}
}
/**
*
* @param parentId
* @return
*/
virtual int writeH5Data(hid_t parentId, QVector<size_t> tDims)
{
if (m_Array == NULL)
{ return -85648; }
#if 0
return H5DataArrayWriter<T>::writeArray(parentId, getName(), getNumberOfTuples(), getNumberOfComponents(), getRank(), getDims(), getClassVersion(), m_Array, getFullNameOfClass());
#else
return H5DataArrayWriter::writeDataArray<Self>(parentId, this, tDims);
#endif
}
void TrigonometricPathVessel::finish( const std::vector<double>& buffer ) {
// Store the data calculated during mpi loop
StoreDataVessel::finish( buffer );
// Get current value of all arguments
for(unsigned i=0; i<cargs.size(); ++i) cargs[i]=mymap->getArgument(i);
// Determine closest and second closest point to current position
double lambda=mymap->getLambda();
std::vector<double> dist( getNumberOfComponents() ), dist2( getNumberOfComponents() );;
retrieveSequentialValue( 0, false, dist );
retrieveSequentialValue( 1, false, dist2 );
iclose1=getStoreIndex(0); iclose2=getStoreIndex(1);
double mindist1=dist[0], mindist2=dist2[0];
if( lambda>0.0 ) {
mindist1=-std::log( dist[0] ) / lambda;
mindist2=-std::log( dist2[0] ) / lambda;
}
if( mindist2<mindist1 ) {
double tmp=mindist1; mindist1=mindist2; mindist2=tmp;
iclose1=getStoreIndex(1); iclose2=getStoreIndex(0);
}
for(unsigned i=2; i<getNumberOfStoredValues(); ++i) {
retrieveSequentialValue( i, false, dist );
double ndist=dist[0];
if( lambda>0.0 ) ndist=-std::log( dist[0] ) / lambda;
if( ndist<mindist1 ) {
mindist2=mindist1; iclose2=iclose1;
mindist1=ndist; iclose1=getStoreIndex(i);
} else if( ndist<mindist2 ) {
mindist2=ndist; iclose2=getStoreIndex(i);
}
}
// And find third closest point
int isign = iclose1 - iclose2;
if( isign>1 ) isign=1; else if( isign<-1 ) isign=-1;
int iclose3 = iclose1 + isign; double v2v2;
// We now have to compute vectors connecting the three closest points to the
// new point
double v1v1 = (mymap->getReferenceConfiguration( iclose1 ))->calculate( mymap->getPositions(), mymap->getPbc(), mymap->getArguments(), mypack1, true );
double v3v3 = (mymap->getReferenceConfiguration( iclose2 ))->calculate( mymap->getPositions(), mymap->getPbc(), mymap->getArguments(), mypack3, true );
if( iclose3<0 || iclose3>=mymap->getFullNumberOfTasks() ) {
ReferenceConfiguration* conf2=mymap->getReferenceConfiguration( iclose1 );
v2v2=(mymap->getReferenceConfiguration( iclose2 ))->calc( conf2->getReferencePositions(), mymap->getPbc(), mymap->getArguments(),
conf2->getReferenceArguments(), mypack2, true );
(mymap->getReferenceConfiguration( iclose2 ))->extractDisplacementVector( conf2->getReferencePositions(), mymap->getArguments(),
conf2->getReferenceArguments(), false, projdir );
} else {
ReferenceConfiguration* conf2=mymap->getReferenceConfiguration( iclose3 );
v2v2=(mymap->getReferenceConfiguration( iclose1 ))->calc( conf2->getReferencePositions(), mymap->getPbc(), mymap->getArguments(),
conf2->getReferenceArguments(), mypack2, true );
(mymap->getReferenceConfiguration( iclose1 ))->extractDisplacementVector( conf2->getReferencePositions(), mymap->getArguments(),
conf2->getReferenceArguments(), false, projdir );
}
// Stash derivatives of v1v1
for(unsigned i=0; i<mymap->getNumberOfArguments(); ++i) mypack1_stashd_args[i]=mypack1.getArgumentDerivative(i);
if( mymap->getNumberOfAtoms()>0 ) {
ReferenceAtoms* at = dynamic_cast<ReferenceAtoms*>( mymap->getReferenceConfiguration( iclose1 ) );
const std::vector<double> & displace( at->getDisplace() );
for(unsigned i=0; i<mymap->getNumberOfAtoms(); ++i) {
mypack1_stashd_atoms[i]=mypack1.getAtomDerivative(i); mypack1.getAtomsDisplacementVector()[i] /= displace[i];
}
}
// Calculate the dot product of v1 with v2
double v1v2 = (mymap->getReferenceConfiguration(iclose1))->projectDisplacementOnVector( projdir, mymap->getArguments(), cargs, mypack1 );
// This computes s value
double spacing = mymap->getPropertyValue( iclose1, (mymap->property.begin())->first ) - mymap->getPropertyValue( iclose2, (mymap->property.begin())->first );
double root = sqrt( v1v2*v1v2 - v2v2 * ( v1v1 - v3v3) );
dx = 0.5 * ( (root + v1v2) / v2v2 - 1.);
double path_s = mymap->getPropertyValue(iclose1, (mymap->property.begin())->first ) + spacing * dx; sp->set( path_s );
double fact = 0.25*spacing / v2v2;
// Derivative of s wrt arguments
for(unsigned i=0; i<mymap->getNumberOfArguments(); ++i) {
sp->setDerivative( i, fact*( mypack2.getArgumentDerivative(i) + (v2v2 * (-mypack1_stashd_args[i] + mypack3.getArgumentDerivative(i))
+ v1v2*mypack2.getArgumentDerivative(i) )/root ) );
}
// Derivative of s wrt atoms
unsigned narg=mymap->getNumberOfArguments(); Tensor vir; vir.zero(); fact = 0.5*spacing / v2v2;
if( mymap->getNumberOfAtoms()>0 ) {
for(unsigned i=0; i<mymap->getNumberOfAtoms(); ++i) {
Vector ader = fact*(( v1v2*mypack1.getAtomDerivative(i) + 0.5*v2v2*(-mypack1_stashd_atoms[i] + mypack3.getAtomDerivative(i) ) )/root + mypack1.getAtomDerivative(i) );
for(unsigned k=0; k<3; ++k) sp->setDerivative( narg+3*i+k, ader[k] );
vir-=Tensor( mymap->getPosition(i), ader );
}
// Set the virial
unsigned nbase=narg+3*mymap->getNumberOfAtoms();
for(unsigned i=0; i<3; ++i) for(unsigned j=0; j<3; ++j) sp->setDerivative( nbase+3*i+j, vir(i,j) );
}
// Now compute z value
ReferenceConfiguration* conf2=mymap->getReferenceConfiguration( iclose1 );
double v4v4=(mymap->getReferenceConfiguration( iclose2 ))->calc( conf2->getReferencePositions(), mymap->getPbc(), mymap->getArguments(),
conf2->getReferenceArguments(), mypack2, true );
// Extract vector connecting frames
(mymap->getReferenceConfiguration( iclose2 ))->extractDisplacementVector( conf2->getReferencePositions(), mymap->getArguments(),
conf2->getReferenceArguments(), false, projdir );
// Calculate projection of vector on line connnecting frames
double proj = (mymap->getReferenceConfiguration(iclose1))->projectDisplacementOnVector( projdir, mymap->getArguments(), cargs, mypack1 );
double path_z = v1v1 + dx*dx*v4v4 - 2*dx*proj;
// Derivatives for z path
path_z = sqrt(path_z); zp->set( path_z ); vir.zero();
for(unsigned i=0; i<mymap->getNumberOfArguments(); ++i) zp->setDerivative( i, (mypack1_stashd_args[i] - 2*dx*mypack1.getArgumentDerivative(i))/(2.0*path_z) );
// Derivative wrt atoms
if( mymap->getNumberOfAtoms()>0 ) {
for(unsigned i=0; i<mymap->getNumberOfAtoms(); ++i) {
Vector dxder; for(unsigned k=0; k<3; ++k) dxder[k] = ( 2*v4v4*dx - 2*proj )*spacing*sp->getDerivative( narg + 3*i+k );
Vector ader = ( mypack1_stashd_atoms[i] - 2.*dx*mypack1.getAtomDerivative(i) + dxder )/ (2.0*path_z);
for(unsigned k=0; k<3; ++k) zp->setDerivative( narg+3*i+k, ader[k] );
vir-=Tensor( mymap->getPosition(i), ader );
}
// Set the virial
unsigned nbase=narg+3*mymap->getNumberOfAtoms();
for(unsigned i=0; i<3; ++i) for(unsigned j=0; j<3; ++j) zp->setDerivative( nbase+3*i+j, vir(i,j) );
}
}
void ManyRestraintsBase::apply() {
plumed_dbg_assert( getNumberOfComponents()==1 );
getPntrToComponent(0)->addForce( -1.0*getStride() );
}
